@mavonengine/core 0.0.2

package/dist/cjs/Prefab/Lights/index.cjs

@@ -0,0 +1,233 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Lights_exports = {};
+__export(Lights_exports, {
+  AmbientLightPrimitive: () => AmbientLightPrimitive,
+  DirectionalLightPrimitive: () => DirectionalLightPrimitive,
+  DirectionalLightShadowPrimitive: () => DirectionalLightShadowPrimitive,
+  GridHelperPrimitive: () => GridHelperPrimitive,
+  HemisphereLightPrimitive: () => HemisphereLightPrimitive,
+  LIGHT_REGISTRY: () => LIGHT_REGISTRY,
+  LightPrimitive: () => LightPrimitive,
+  LightProbePrimitive: () => LightProbePrimitive,
+  PlaneHelperPrimitive: () => PlaneHelperPrimitive,
+  PointLightPrimitive: () => PointLightPrimitive,
+  PointLightShadowPrimitive: () => PointLightShadowPrimitive,
+  PolarGridHelperPrimitive: () => PolarGridHelperPrimitive,
+  RectAreaLightPrimitive: () => RectAreaLightPrimitive,
+  SCENE_HELPER_REGISTRY: () => SCENE_HELPER_REGISTRY,
+  SkeletonHelperPrimitive: () => SkeletonHelperPrimitive,
+  SpotLightPrimitive: () => SpotLightPrimitive,
+  SpotLightShadowPrimitive: () => SpotLightShadowPrimitive
+});
+module.exports = __toCommonJS(Lights_exports);
+var import_three = require("three");
+var import_WithEditorHelper = require("../../Editor/WithEditorHelper");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+class LightPrimitive extends (0, import_WithEditorHelper.WithEditorHelper)(import_GameObject.default) {
+  constructor(position, light, label) {
+    super(void 0, position);
+    this.instance = light;
+    this.instance.position.copy(position);
+    import_Game.default.instance().scene.add(this.instance);
+    this.registerEditorHelper(position, label, {
+      onMove: (delta) => this.instance.position.add(delta),
+      properties: [
+        { type: "color", label: "color", getValue: () => `#${this.instance.color.getHexString()}`, setValue: (v) => this.instance.color.set(v) },
+        { type: "slider", label: "intensity", min: 0, max: 10, step: 0.01, getValue: () => this.instance.intensity, setValue: (v) => this.instance.intensity = v },
+        { type: "checkbox", label: "castShadow", getValue: () => this.instance.castShadow, setValue: (v) => this.instance.castShadow = v }
+      ]
+    });
+    this.tagWithHelper(this.instance);
+  }
+  addLightHelper(helper) {
+    const editor = import_Game.default.instance().editor;
+    if (!editor)
+      return;
+    this.lightHelper = helper;
+    import_Game.default.instance().scene.add(helper);
+    editor.addLightHelper(helper);
+  }
+  update(_delta) {
+    this.lightHelper?.update();
+  }
+  destroy() {
+    if (this.lightHelper) {
+      import_Game.default.instance().editor?.removeLightHelper(this.lightHelper);
+      import_Game.default.instance().scene.remove(this.lightHelper);
+      this.lightHelper = void 0;
+    }
+    import_Game.default.instance().scene.remove(this.instance);
+    super.destroy();
+  }
+}
+class AmbientLightPrimitive extends LightPrimitive {
+  constructor(position) {
+    super(position, new import_three.AmbientLight(16777215, 1), "AmbientLight");
+  }
+}
+class DirectionalLightPrimitive extends LightPrimitive {
+  constructor(position) {
+    super(position, new import_three.DirectionalLight(16777215, 1), "DirectionalLight");
+    this.addLightHelper(new import_three.DirectionalLightHelper(this.instance));
+  }
+}
+class DirectionalLightShadowPrimitive extends LightPrimitive {
+  constructor(position) {
+    const light = new import_three.DirectionalLight(16777215, 1);
+    light.castShadow = true;
+    super(position, light, "DirectionalLightShadow");
+    this.addLightHelper(new import_three.DirectionalLightHelper(this.instance));
+  }
+}
+class HemisphereLightPrimitive extends LightPrimitive {
+  constructor(position) {
+    super(position, new import_three.HemisphereLight(16777215, 4473924, 1), "HemisphereLight");
+    this.addLightHelper(new import_three.HemisphereLightHelper(this.instance, 1));
+  }
+}
+class LightProbePrimitive extends LightPrimitive {
+  constructor(position) {
+    super(position, new import_three.LightProbe(), "LightProbe");
+  }
+}
+class PointLightPrimitive extends LightPrimitive {
+  constructor(position) {
+    super(position, new import_three.PointLight(16777215, 1), "PointLight");
+    this.addLightHelper(new import_three.PointLightHelper(this.instance));
+  }
+}
+class PointLightShadowPrimitive extends LightPrimitive {
+  constructor(position) {
+    const light = new import_three.PointLight(16777215, 1);
+    light.castShadow = true;
+    super(position, light, "PointLightShadow");
+    this.addLightHelper(new import_three.PointLightHelper(this.instance));
+  }
+}
+class RectAreaLightPrimitive extends LightPrimitive {
+  constructor(position) {
+    super(position, new import_three.RectAreaLight(16777215, 1, 4, 4), "RectAreaLight");
+  }
+}
+class SpotLightPrimitive extends LightPrimitive {
+  constructor(position) {
+    super(position, new import_three.SpotLight(16777215, 1), "SpotLight");
+    this.addLightHelper(new import_three.SpotLightHelper(this.instance));
+  }
+}
+class SpotLightShadowPrimitive extends LightPrimitive {
+  constructor(position) {
+    const light = new import_three.SpotLight(16777215, 1);
+    light.castShadow = true;
+    super(position, light, "SpotLightShadow");
+    this.addLightHelper(new import_three.SpotLightHelper(this.instance));
+  }
+}
+class SceneHelperPrimitive extends (0, import_WithEditorHelper.WithEditorHelper)(import_GameObject.default) {
+  constructor(position, helper, label) {
+    super(void 0, position);
+    this.helper = helper;
+    this.helper.position.copy(position);
+    import_Game.default.instance().scene.add(this.helper);
+    this.registerEditorHelper(position, label, {
+      onMove: (delta) => this.helper.position.add(delta)
+    });
+    this.tagWithHelper(this.helper);
+    import_Game.default.instance().editor?.addLightHelper(this.helper);
+  }
+  update(_delta) {
+  }
+  destroy() {
+    import_Game.default.instance().editor?.removeLightHelper(this.helper);
+    import_Game.default.instance().scene.remove(this.helper);
+    super.destroy();
+  }
+}
+class GridHelperPrimitive extends SceneHelperPrimitive {
+  constructor(position) {
+    super(position, new import_three.GridHelper(10, 10), "GridHelper");
+  }
+}
+class PolarGridHelperPrimitive extends SceneHelperPrimitive {
+  constructor(position) {
+    super(position, new import_three.PolarGridHelper(10, 16), "PolarGridHelper");
+  }
+}
+class PlaneHelperPrimitive extends SceneHelperPrimitive {
+  constructor(position) {
+    super(position, new import_three.PlaneHelper(new import_three.Plane(new import_three.Vector3(0, 1, 0), -position.y), 10), "PlaneHelper");
+  }
+}
+class SkeletonHelperPrimitive extends SceneHelperPrimitive {
+  constructor(position) {
+    const root = new import_three.Object3D();
+    root.position.copy(position);
+    super(position, new import_three.SkeletonHelper(root), "SkeletonHelper");
+  }
+}
+const LIGHT_REGISTRY = {
+  AmbientLight: AmbientLightPrimitive,
+  DirectionalLight: DirectionalLightPrimitive,
+  DirectionalLightShadow: DirectionalLightShadowPrimitive,
+  HemisphereLight: HemisphereLightPrimitive,
+  LightProbe: LightProbePrimitive,
+  PointLight: PointLightPrimitive,
+  PointLightShadow: PointLightShadowPrimitive,
+  RectAreaLight: RectAreaLightPrimitive,
+  SpotLight: SpotLightPrimitive,
+  SpotLightShadow: SpotLightShadowPrimitive
+};
+const SCENE_HELPER_REGISTRY = {
+  GridHelper: GridHelperPrimitive,
+  PolarGridHelper: PolarGridHelperPrimitive,
+  PlaneHelper: PlaneHelperPrimitive,
+  SkeletonHelper: SkeletonHelperPrimitive
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmbientLightPrimitive,
+  DirectionalLightPrimitive,
+  DirectionalLightShadowPrimitive,
+  GridHelperPrimitive,
+  HemisphereLightPrimitive,
+  LIGHT_REGISTRY,
+  LightPrimitive,
+  LightProbePrimitive,
+  PlaneHelperPrimitive,
+  PointLightPrimitive,
+  PointLightShadowPrimitive,
+  PolarGridHelperPrimitive,
+  RectAreaLightPrimitive,
+  SCENE_HELPER_REGISTRY,
+  SkeletonHelperPrimitive,
+  SpotLightPrimitive,
+  SpotLightShadowPrimitive
+});

package/dist/cjs/Prefab/Primitives/index.cjs

@@ -0,0 +1,300 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Primitives_exports = {};
+__export(Primitives_exports, {
+  BoxPrimitive: () => BoxPrimitive,
+  CapsulePrimitive: () => CapsulePrimitive,
+  CirclePrimitive: () => CirclePrimitive,
+  ConePrimitive: () => ConePrimitive,
+  CylinderPrimitive: () => CylinderPrimitive,
+  DodecahedronPrimitive: () => DodecahedronPrimitive,
+  EdgesPrimitive: () => EdgesPrimitive,
+  ExtrudePrimitive: () => ExtrudePrimitive,
+  IcosahedronPrimitive: () => IcosahedronPrimitive,
+  LathePrimitive: () => LathePrimitive,
+  OctahedronPrimitive: () => OctahedronPrimitive,
+  PRIMITIVE_REGISTRY: () => PRIMITIVE_REGISTRY,
+  PlanePrimitive: () => PlanePrimitive,
+  PolyhedronPrimitive: () => PolyhedronPrimitive,
+  Primitive: () => Primitive,
+  RingPrimitive: () => RingPrimitive,
+  ShapePrimitive: () => ShapePrimitive,
+  SpherePrimitive: () => SpherePrimitive,
+  TetrahedronPrimitive: () => TetrahedronPrimitive,
+  TorusKnotPrimitive: () => TorusKnotPrimitive,
+  TorusPrimitive: () => TorusPrimitive,
+  TubePrimitive: () => TubePrimitive,
+  WireframePrimitive: () => WireframePrimitive
+});
+module.exports = __toCommonJS(Primitives_exports);
+var import_three = require("three");
+var import_WithEditorHelper = require("../../Editor/WithEditorHelper");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+class Primitive extends (0, import_WithEditorHelper.WithEditorHelper)(import_GameObject.default) {
+  constructor(position, object, label) {
+    super(void 0, position);
+    this.instance = object;
+    this.instance.position.copy(position);
+    import_Game.default.instance().scene.add(this.instance);
+    const isMeshStd = this.instance instanceof import_three.Mesh && this.instance.material instanceof import_three.MeshStandardMaterial;
+    const mat = isMeshStd ? this.instance.material : null;
+    this.registerEditorHelper(position, label, {
+      onMove: (delta) => this.instance.position.add(delta),
+      properties: mat ? [
+        { type: "color", label: "color", getValue: () => `#${mat.color.getHexString()}`, setValue: (v) => mat.color.set(v) },
+        {
+          type: "checkbox",
+          label: "wireframe",
+          getValue: () => mat.wireframe,
+          setValue: (v) => {
+            mat.wireframe = v;
+            mat.needsUpdate = true;
+          }
+        },
+        { type: "slider", label: "roughness", min: 0, max: 1, step: 0.01, getValue: () => mat.roughness, setValue: (v) => {
+          mat.roughness = v;
+        } },
+        { type: "slider", label: "metalness", min: 0, max: 1, step: 0.01, getValue: () => mat.metalness, setValue: (v) => {
+          mat.metalness = v;
+        } }
+      ] : []
+    });
+    this.tagWithHelper(this.instance);
+  }
+  setReceiveShadow(value) {
+    if (this.instance instanceof import_three.Mesh) {
+      this.instance.receiveShadow = value;
+    }
+  }
+  setCastShadow(value) {
+    if (this.instance instanceof import_three.Mesh) {
+      this.instance.castShadow = value;
+    }
+  }
+  update(_delta) {
+  }
+  destroy() {
+    const asRenderable = this.instance;
+    asRenderable.geometry?.dispose();
+    if (Array.isArray(asRenderable.material)) {
+      asRenderable.material.forEach((m) => m.dispose());
+    } else {
+      asRenderable.material?.dispose();
+    }
+    import_Game.default.instance().scene.remove(this.instance);
+    super.destroy();
+  }
+}
+function mesh(geometry) {
+  return new import_three.Mesh(geometry, new import_three.MeshStandardMaterial({ color: 8947848 }));
+}
+function lines(geometry) {
+  return new import_three.LineSegments(geometry, new import_three.LineBasicMaterial({ color: 4890367 }));
+}
+class BoxPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.BoxGeometry()), "Box");
+  }
+}
+class CapsulePrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.CapsuleGeometry()), "Capsule");
+  }
+}
+class CirclePrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.CircleGeometry()), "Circle");
+  }
+}
+class ConePrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.ConeGeometry()), "Cone");
+  }
+}
+class CylinderPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.CylinderGeometry()), "Cylinder");
+  }
+}
+class DodecahedronPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.DodecahedronGeometry()), "Dodecahedron");
+  }
+}
+class EdgesPrimitive extends Primitive {
+  constructor(position) {
+    super(position, lines(new import_three.EdgesGeometry(new import_three.BoxGeometry())), "Edges");
+  }
+}
+class ExtrudePrimitive extends Primitive {
+  constructor(position) {
+    const shape = new import_three.Shape();
+    shape.moveTo(0, 0);
+    shape.lineTo(0, 1);
+    shape.lineTo(1, 1);
+    shape.lineTo(1, 0);
+    shape.closePath();
+    super(position, mesh(new import_three.ExtrudeGeometry(shape, { depth: 0.5, bevelEnabled: false })), "Extrude");
+  }
+}
+class IcosahedronPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.IcosahedronGeometry()), "Icosahedron");
+  }
+}
+class LathePrimitive extends Primitive {
+  constructor(position) {
+    const points = [];
+    for (let i = 0; i <= 10; i++) {
+      points.push(new import_three.Vector2(Math.sin(i * 0.2) * 0.5 + 0.3, i * 0.1));
+    }
+    super(position, mesh(new import_three.LatheGeometry(points, 12)), "Lathe");
+  }
+}
+class OctahedronPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.OctahedronGeometry()), "Octahedron");
+  }
+}
+class PlanePrimitive extends Primitive {
+  constructor(position, width = 1, height = 1) {
+    const geometry = new import_three.PlaneGeometry(width, height);
+    geometry.rotateX(-Math.PI / 2);
+    super(position, mesh(geometry), "Plane");
+  }
+}
+class PolyhedronPrimitive extends Primitive {
+  constructor(position) {
+    const vertices = [1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1];
+    const indices = [2, 1, 0, 0, 3, 2, 1, 3, 0, 2, 3, 1];
+    super(position, mesh(new import_three.PolyhedronGeometry(vertices, indices, 0.8, 2)), "Polyhedron");
+  }
+}
+class RingPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.RingGeometry(0.5, 1)), "Ring");
+  }
+}
+class ShapePrimitive extends Primitive {
+  constructor(position) {
+    const shape = new import_three.Shape();
+    shape.moveTo(0, 0);
+    shape.lineTo(0, 1);
+    shape.lineTo(1, 1);
+    shape.lineTo(1, 0);
+    shape.closePath();
+    super(position, mesh(new import_three.ShapeGeometry(shape)), "Shape");
+  }
+}
+class SpherePrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.SphereGeometry()), "Sphere");
+  }
+}
+class TetrahedronPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.TetrahedronGeometry()), "Tetrahedron");
+  }
+}
+class TorusPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.TorusGeometry()), "Torus");
+  }
+}
+class TorusKnotPrimitive extends Primitive {
+  constructor(position) {
+    super(position, mesh(new import_three.TorusKnotGeometry()), "TorusKnot");
+  }
+}
+class TubePrimitive extends Primitive {
+  constructor(position) {
+    const path = new import_three.CatmullRomCurve3([
+      new import_three.Vector3(-1, 0, 0),
+      new import_three.Vector3(-0.5, 0.5, 0),
+      new import_three.Vector3(0.5, -0.5, 0),
+      new import_three.Vector3(1, 0, 0)
+    ]);
+    super(position, mesh(new import_three.TubeGeometry(path, 20, 0.2, 8, false)), "Tube");
+  }
+}
+class WireframePrimitive extends Primitive {
+  constructor(position) {
+    super(position, lines(new import_three.WireframeGeometry(new import_three.BoxGeometry())), "Wireframe");
+  }
+}
+const PRIMITIVE_REGISTRY = {
+  Box: BoxPrimitive,
+  Capsule: CapsulePrimitive,
+  Circle: CirclePrimitive,
+  Cone: ConePrimitive,
+  Cylinder: CylinderPrimitive,
+  Dodecahedron: DodecahedronPrimitive,
+  Edges: EdgesPrimitive,
+  Extrude: ExtrudePrimitive,
+  Icosahedron: IcosahedronPrimitive,
+  Lathe: LathePrimitive,
+  Octahedron: OctahedronPrimitive,
+  Plane: PlanePrimitive,
+  Polyhedron: PolyhedronPrimitive,
+  Ring: RingPrimitive,
+  Shape: ShapePrimitive,
+  Sphere: SpherePrimitive,
+  Tetrahedron: TetrahedronPrimitive,
+  Torus: TorusPrimitive,
+  TorusKnot: TorusKnotPrimitive,
+  Tube: TubePrimitive,
+  Wireframe: WireframePrimitive
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BoxPrimitive,
+  CapsulePrimitive,
+  CirclePrimitive,
+  ConePrimitive,
+  CylinderPrimitive,
+  DodecahedronPrimitive,
+  EdgesPrimitive,
+  ExtrudePrimitive,
+  IcosahedronPrimitive,
+  LathePrimitive,
+  OctahedronPrimitive,
+  PRIMITIVE_REGISTRY,
+  PlanePrimitive,
+  PolyhedronPrimitive,
+  Primitive,
+  RingPrimitive,
+  ShapePrimitive,
+  SpherePrimitive,
+  TetrahedronPrimitive,
+  TorusKnotPrimitive,
+  TorusPrimitive,
+  TubePrimitive,
+  WireframePrimitive
+});