@mavonengine/core 0.0.2

package/dist/Prefab/Lights/index.js

@@ -0,0 +1,164 @@
+import { AmbientLight, DirectionalLight, DirectionalLightHelper, GridHelper, HemisphereLight, HemisphereLightHelper, LightProbe, Object3D, Plane, PlaneHelper, PointLight, PointLightHelper, PolarGridHelper, RectAreaLight, SkeletonHelper, SpotLight, SpotLightHelper, Vector3, } from 'three';
+import { WithEditorHelper } from '../../Editor/WithEditorHelper';
+import Game from '../../Game';
+import GameObject from '../../World/GameObject';
+export class LightPrimitive extends WithEditorHelper(GameObject) {
+    constructor(position, light, label) {
+        super(undefined, position);
+        this.instance = light;
+        this.instance.position.copy(position);
+        Game.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 = Game.instance().editor;
+        if (!editor)
+            return;
+        this.lightHelper = helper;
+        Game.instance().scene.add(helper);
+        editor.addLightHelper(helper);
+    }
+    update(_delta) {
+        this.lightHelper?.update();
+    }
+    destroy() {
+        if (this.lightHelper) {
+            Game.instance().editor?.removeLightHelper(this.lightHelper);
+            Game.instance().scene.remove(this.lightHelper);
+            this.lightHelper = undefined;
+        }
+        Game.instance().scene.remove(this.instance);
+        super.destroy();
+    }
+}
+export class AmbientLightPrimitive extends LightPrimitive {
+    constructor(position) {
+        super(position, new AmbientLight(0xFFFFFF, 1), 'AmbientLight');
+    }
+}
+export class DirectionalLightPrimitive extends LightPrimitive {
+    constructor(position) {
+        super(position, new DirectionalLight(0xFFFFFF, 1), 'DirectionalLight');
+        this.addLightHelper(new DirectionalLightHelper(this.instance));
+    }
+}
+export class DirectionalLightShadowPrimitive extends LightPrimitive {
+    constructor(position) {
+        const light = new DirectionalLight(0xFFFFFF, 1);
+        light.castShadow = true;
+        super(position, light, 'DirectionalLightShadow');
+        this.addLightHelper(new DirectionalLightHelper(this.instance));
+    }
+}
+export class HemisphereLightPrimitive extends LightPrimitive {
+    constructor(position) {
+        super(position, new HemisphereLight(0xFFFFFF, 0x444444, 1), 'HemisphereLight');
+        this.addLightHelper(new HemisphereLightHelper(this.instance, 1));
+    }
+}
+export class LightProbePrimitive extends LightPrimitive {
+    constructor(position) {
+        super(position, new LightProbe(), 'LightProbe');
+    }
+}
+export class PointLightPrimitive extends LightPrimitive {
+    constructor(position) {
+        super(position, new PointLight(0xFFFFFF, 1), 'PointLight');
+        this.addLightHelper(new PointLightHelper(this.instance));
+    }
+}
+export class PointLightShadowPrimitive extends LightPrimitive {
+    constructor(position) {
+        const light = new PointLight(0xFFFFFF, 1);
+        light.castShadow = true;
+        super(position, light, 'PointLightShadow');
+        this.addLightHelper(new PointLightHelper(this.instance));
+    }
+}
+export class RectAreaLightPrimitive extends LightPrimitive {
+    constructor(position) {
+        super(position, new RectAreaLight(0xFFFFFF, 1, 4, 4), 'RectAreaLight');
+    }
+}
+export class SpotLightPrimitive extends LightPrimitive {
+    constructor(position) {
+        super(position, new SpotLight(0xFFFFFF, 1), 'SpotLight');
+        this.addLightHelper(new SpotLightHelper(this.instance));
+    }
+}
+export class SpotLightShadowPrimitive extends LightPrimitive {
+    constructor(position) {
+        const light = new SpotLight(0xFFFFFF, 1);
+        light.castShadow = true;
+        super(position, light, 'SpotLightShadow');
+        this.addLightHelper(new SpotLightHelper(this.instance));
+    }
+}
+// ─── Standalone scene-level helpers (editor-only) ──────────────────────────
+class SceneHelperPrimitive extends WithEditorHelper(GameObject) {
+    constructor(position, helper, label) {
+        super(undefined, position);
+        this.helper = helper;
+        this.helper.position.copy(position);
+        Game.instance().scene.add(this.helper);
+        this.registerEditorHelper(position, label, {
+            onMove: (delta) => this.helper.position.add(delta),
+        });
+        this.tagWithHelper(this.helper);
+        Game.instance().editor?.addLightHelper(this.helper);
+    }
+    update(_delta) { }
+    destroy() {
+        Game.instance().editor?.removeLightHelper(this.helper);
+        Game.instance().scene.remove(this.helper);
+        super.destroy();
+    }
+}
+export class GridHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position) {
+        super(position, new GridHelper(10, 10), 'GridHelper');
+    }
+}
+export class PolarGridHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position) {
+        super(position, new PolarGridHelper(10, 16), 'PolarGridHelper');
+    }
+}
+export class PlaneHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position) {
+        super(position, new PlaneHelper(new Plane(new Vector3(0, 1, 0), -position.y), 10), 'PlaneHelper');
+    }
+}
+export class SkeletonHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position) {
+        const root = new Object3D();
+        root.position.copy(position);
+        super(position, new SkeletonHelper(root), 'SkeletonHelper');
+    }
+}
+export const LIGHT_REGISTRY = {
+    AmbientLight: AmbientLightPrimitive,
+    DirectionalLight: DirectionalLightPrimitive,
+    DirectionalLightShadow: DirectionalLightShadowPrimitive,
+    HemisphereLight: HemisphereLightPrimitive,
+    LightProbe: LightProbePrimitive,
+    PointLight: PointLightPrimitive,
+    PointLightShadow: PointLightShadowPrimitive,
+    RectAreaLight: RectAreaLightPrimitive,
+    SpotLight: SpotLightPrimitive,
+    SpotLightShadow: SpotLightShadowPrimitive,
+};
+export const SCENE_HELPER_REGISTRY = {
+    GridHelper: GridHelperPrimitive,
+    PolarGridHelper: PolarGridHelperPrimitive,
+    PlaneHelper: PlaneHelperPrimitive,
+    SkeletonHelper: SkeletonHelperPrimitive,
+};

package/dist/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
+});

package/dist/Prefab/Primitives/index.d.ts

@@ -0,0 +1,82 @@
+import type { Object3D } from 'three';
+import { Vector3 } from 'three';
+import GameObject from '../../World/GameObject';
+declare const Primitive_base: (abstract new (...args: any[]) => {
+    editorHelper: import("../../Editor/EditorHelper").default | undefined;
+    registerEditorHelper(position: Vector3, label: string, attachment?: import("../../Editor/EditorHelper").EditorHelperAttachment | null): void;
+    tagWithHelper(mesh: Object3D): void;
+    destroy(): void;
+}) & typeof GameObject;
+export declare abstract class Primitive extends Primitive_base {
+    instance: Object3D;
+    constructor(position: Vector3, object: Object3D, label: string);
+    setReceiveShadow(value: boolean): void;
+    setCastShadow(value: boolean): void;
+    update(_delta: number): void;
+    destroy(): void;
+}
+export declare class BoxPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class CapsulePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class CirclePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class ConePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class CylinderPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class DodecahedronPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class EdgesPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class ExtrudePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class IcosahedronPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class LathePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class OctahedronPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class PlanePrimitive extends Primitive {
+    constructor(position: Vector3, width?: number, height?: number);
+}
+export declare class PolyhedronPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class RingPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class ShapePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class SpherePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class TetrahedronPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class TorusPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class TorusKnotPrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class TubePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare class WireframePrimitive extends Primitive {
+    constructor(position: Vector3);
+}
+export declare const PRIMITIVE_REGISTRY: Record<string, new (position: Vector3) => Primitive>;
+export {};