@mavonengine/core 0.0.2

package/dist/Prefab/Grass/Grass.d.ts

@@ -0,0 +1,32 @@
+import type { ContainerApi } from '@tweakpane/core';
+import type { GLTF } from 'three/examples/jsm/Addons.js';
+import Entity3D from '../../World/Entity3D';
+import { Mesh, ShaderMaterial, Vector3 } from 'three';
+declare const Grass_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: import("three").Object3D): void;
+    destroy(): void;
+}) & typeof Entity3D;
+export default class Grass extends Grass_base {
+    material?: ShaderMaterial;
+    lowResMaterial?: ShaderMaterial;
+    instancePositions: Float32Array;
+    mesh?: Mesh;
+    lowResMesh?: Mesh;
+    private highGeometry?;
+    private lowGeometry?;
+    private patchSize;
+    private coordCallback?;
+    constructor(highModel: GLTF, lowModel: GLTF, grassBlades?: number, patchSize?: number, position?: Vector3, coordCallback?: (x: number, y: number) => number);
+    private build;
+    reallocate(grassBlades: number): void;
+    addBindings(folder: ContainerApi): void;
+    destroy(): void;
+    setPushPoints(points: {
+        position: Vector3;
+        radius: number;
+    }[]): void;
+    update(delta: number): void;
+}
+export {};

package/dist/Prefab/Grass/Grass.js

@@ -0,0 +1,182 @@
+import { WithEditorHelper } from '../../Editor/WithEditorHelper';
+import Game from '../../Game';
+import { randRange } from '../../Utils/Math';
+import Entity3D from '../../World/Entity3D';
+import { Box3, DoubleSide, InstancedBufferAttribute, InstancedBufferGeometry, Mesh, ShaderMaterial, Sphere, Vector3, } from 'three';
+import { clone } from 'three/examples/jsm/utils/SkeletonUtils.js';
+import FragmentShader from './Fragment.glsl';
+import VertexShader from './Vertex.glsl';
+const MAX_PUSH_POINTS = 150;
+export default class Grass extends WithEditorHelper(Entity3D) {
+    constructor(highModel, lowModel, grassBlades = 200000, patchSize = 12.5, position = new Vector3(), coordCallback) {
+        super();
+        this.instancePositions = new Float32Array(grassBlades * 3);
+        this.patchSize = patchSize;
+        this.position = position;
+        this.coordCallback = coordCallback;
+        this.registerEditorHelper(position, 'Grass', this);
+        const onLoad = () => {
+            const highSource = clone(highModel.scene.clone()).children.find(child => child instanceof Mesh);
+            const lowSource = clone(lowModel.scene.clone()).children.find(child => child instanceof Mesh);
+            if (!highSource || !lowSource) {
+                console.error('No mesh found in model');
+                return;
+            }
+            this.highGeometry = highSource.geometry.clone();
+            this.highGeometry.rotateZ(Math.PI / 180 * 90);
+            this.lowGeometry = lowSource.geometry.clone();
+            this.lowGeometry.rotateZ(Math.PI / 180 * 90);
+            this.build(grassBlades);
+            Game.instance().scene.add(this.mesh, this.lowResMesh);
+        };
+        if (Game.instance().resources.loaded) {
+            onLoad();
+        }
+        else {
+            Game.instance().resources.on('loaded', onLoad);
+        }
+    }
+    build(grassBlades) {
+        const { patchSize, position, coordCallback } = this;
+        const positions = new Float32Array(grassBlades * 3);
+        const instanceRotation = new Float32Array(grassBlades);
+        const instanceScales = new Float32Array(grassBlades);
+        let bladeIndex = 0;
+        while (bladeIndex < grassBlades) {
+            const x = randRange(-patchSize, patchSize);
+            const z = randRange(-patchSize, patchSize);
+            const distSq = x * x + z * z;
+            const maxDistSq = patchSize * patchSize;
+            const densityFalloff = Math.exp(-distSq / (maxDistSq * 0.1));
+            if (Math.random() < densityFalloff) {
+                positions[bladeIndex * 3] = x;
+                positions[bladeIndex * 3 + 1] = coordCallback ? coordCallback(x, z) : 0;
+                positions[bladeIndex * 3 + 2] = z;
+                instanceRotation[bladeIndex] = Math.random() * Math.PI * 2;
+                instanceScales[bladeIndex] = randRange(2.3, 3.5);
+                bladeIndex++;
+            }
+        }
+        const instanceLeans = new Float32Array(grassBlades);
+        for (let i = 0; i < grassBlades; i++) {
+            instanceLeans[i] = randRange(-0.4, 0.4);
+        }
+        const buildGeometry = (baseGeometry) => {
+            const geometry = new InstancedBufferGeometry();
+            geometry.index = baseGeometry.index;
+            geometry.attributes = { ...baseGeometry.attributes };
+            geometry.setAttribute('offset', new InstancedBufferAttribute(positions, 3));
+            geometry.setAttribute('rotationAngle', new InstancedBufferAttribute(instanceRotation, 1));
+            geometry.setAttribute('instanceScale', new InstancedBufferAttribute(instanceScales, 1));
+            geometry.setAttribute('randomLean', new InstancedBufferAttribute(instanceLeans, 1));
+            geometry.instanceCount = grassBlades;
+            geometry.boundingBox = new Box3(new Vector3(-patchSize, -patchSize, -patchSize), new Vector3(patchSize, patchSize, patchSize));
+            geometry.boundingSphere = geometry.boundingBox.getBoundingSphere(new Sphere());
+            const material = new ShaderMaterial({
+                vertexShader: VertexShader,
+                fragmentShader: FragmentShader,
+                side: DoubleSide,
+                uniforms: {
+                    uTime: { value: 0 },
+                    pushPositions: {
+                        value: Array.from({ length: MAX_PUSH_POINTS }, () => new Vector3()),
+                    },
+                    pushRadii: {
+                        value: Array.from({ length: MAX_PUSH_POINTS }).fill(0),
+                    },
+                },
+            });
+            const mesh = new Mesh(geometry, material);
+            mesh.position.copy(position);
+            mesh.userData.grassInstance = this;
+            mesh.raycast = (raycaster, intersects) => {
+                if (!Game.instance().editor)
+                    return;
+                if (!geometry.boundingBox)
+                    return;
+                const box = new Box3().copy(geometry.boundingBox).applyMatrix4(mesh.matrixWorld);
+                const target = new Vector3();
+                if (raycaster.ray.intersectBox(box, target)) {
+                    intersects.push({
+                        distance: raycaster.ray.origin.distanceTo(target),
+                        point: target.clone(),
+                        object: mesh,
+                    });
+                }
+            };
+            return { mesh, material };
+        };
+        if (this.mesh) {
+            // Reallocation: swap geometry on existing meshes
+            this.mesh.geometry.dispose();
+            this.lowResMesh.geometry.dispose();
+            const highGeo = buildGeometry(this.highGeometry).mesh.geometry;
+            const lowGeo = buildGeometry(this.lowGeometry).mesh.geometry;
+            this.mesh.geometry = highGeo;
+            this.lowResMesh.geometry = lowGeo;
+            this.instancePositions = positions;
+        }
+        else {
+            // Initial build
+            const high = buildGeometry(this.highGeometry);
+            this.mesh = high.mesh;
+            this.material = high.material;
+            this.instancePositions = positions;
+            const low = buildGeometry(this.lowGeometry);
+            this.lowResMesh = low.mesh;
+            this.lowResMaterial = low.material;
+            this.lowResMesh.visible = false;
+            this.tagWithHelper(this.mesh);
+            this.tagWithHelper(this.lowResMesh);
+        }
+    }
+    reallocate(grassBlades) {
+        if (!this.highGeometry || !this.lowGeometry)
+            return;
+        this.build(grassBlades);
+    }
+    addBindings(folder) {
+        const proxy = { bladeCount: this.mesh?.geometry.getAttribute('offset')?.count ?? 0 };
+        folder.addBinding(proxy, 'bladeCount', { min: 1000, max: 50000, step: 1000, label: 'Blade Count' })
+            .on('change', ({ value }) => this.reallocate(value));
+    }
+    destroy() {
+        this.material?.dispose();
+        this.lowResMaterial?.dispose();
+        this.mesh?.geometry.dispose();
+        this.lowResMesh?.geometry.dispose();
+        Game.instance().scene.remove(this.mesh, this.lowResMesh);
+        super.destroy();
+    }
+    setPushPoints(points) {
+        const materials = [this.material, this.lowResMaterial].filter((m) => !!m);
+        if (!materials.length)
+            return;
+        for (let i = 0; i < MAX_PUSH_POINTS; i++) {
+            if (points[i]) {
+                materials.forEach((mat) => {
+                    mat.uniforms.pushPositions.value[i].copy(points[i].position);
+                    mat.uniforms.pushRadii.value[i] = points[i].radius;
+                });
+            }
+        }
+    }
+    update(delta) {
+        [this.material, this.lowResMaterial].forEach((mat) => {
+            if (mat)
+                mat.uniforms.uTime.value += delta;
+        });
+        const cameraPos = Game.instance().camera.instance.position;
+        const distance = cameraPos.distanceTo(this.mesh.position);
+        if (this.lowResMesh) {
+            if (distance > 20) {
+                this.lowResMesh.visible = true;
+                this.mesh.visible = false;
+            }
+            else {
+                this.lowResMesh.visible = false;
+                this.mesh.visible = true;
+            }
+        }
+    }
+}

package/dist/Prefab/Grass/GrassAffectingEntity.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var GrassAffectingEntity_exports = {};
+__export(GrassAffectingEntity_exports, {
+  isGrassAffectingEntity: () => isGrassAffectingEntity
+});
+module.exports = __toCommonJS(GrassAffectingEntity_exports);
+function isGrassAffectingEntity(obj) {
+  return typeof obj.getPushPoints === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isGrassAffectingEntity
+});

package/dist/Prefab/Grass/GrassAffectingEntity.d.ts

@@ -0,0 +1,8 @@
+import type { Vector3 } from 'three';
+export default interface GrassAffectingEntity {
+    getPushPoints(): {
+        position: Vector3;
+        radius: number;
+    }[];
+}
+export declare function isGrassAffectingEntity(obj: any): obj is GrassAffectingEntity;

package/dist/Prefab/Grass/GrassAffectingEntity.js

@@ -0,0 +1,3 @@
+export function isGrassAffectingEntity(obj) {
+    return typeof obj.getPushPoints === 'function';
+}

package/dist/Prefab/Grass/Vertex.glsl

@@ -0,0 +1,102 @@
+varying vec2 vUv;
+
+uniform float uTime;
+
+attribute vec3 offset;
+attribute float rotationAngle;
+attribute float instanceScale;
+attribute float randomLean; 
+
+#define MAX_PUSH_POINTS 150
+
+uniform vec3 pushPositions[MAX_PUSH_POINTS];
+uniform float pushRadii[MAX_PUSH_POINTS];
+
+uint murmurHash12(uvec2 src) {
+  const uint M = 0x5bd1e995u;
+  uint h = 1190494759u;
+  src *= M; src ^= src>>24u; src *= M;
+  h *= M; h ^= src.x; h *= M; h ^= src.y;
+  h ^= h>>13u; h *= M; h ^= h>>15u;
+  return h;
+}
+
+float computePushInfluence(vec3 worldPos) {
+    float totalInfluence = 0.0;
+
+    for (int i = 0; i < MAX_PUSH_POINTS; i++) {
+        float dist = distance(worldPos.xz, pushPositions[i].xz);
+        float influence = smoothstep(pushRadii[i], 0.0, dist);
+        totalInfluence = max(totalInfluence, influence); // or sum for additive influence
+    }
+
+    return totalInfluence;
+}
+
+// 1 output, 2 inputs
+float hash12(vec2 src) {
+  uint h = murmurHash12(floatBitsToUint(src));
+  return uintBitsToFloat(h & 0x007fffffu | 0x3f800000u) - 1.0;
+}
+
+float noise12(vec2 p) {
+  vec2 i = floor(p);
+
+  vec2 f = fract(p);
+  vec2 u = smoothstep(vec2(0.0), vec2(1.0), f);
+
+	float val = mix( mix( hash12( i + vec2(0.0, 0.0) ), 
+                        hash12( i + vec2(1.0, 0.0) ), u.x),
+                   mix( hash12( i + vec2(0.0, 1.0) ), 
+                        hash12( i + vec2(1.0, 1.0) ), u.x), u.y);
+  return val * 2.0 - 1.0;
+}
+
+
+void main() {
+    vUv = uv;
+
+    float PI = 3.14159265;
+
+    // Local transformation: scale blade by instanceScale
+    vec3 centered = position;
+    centered.y *= instanceScale;
+
+    // Compute wind direction from noise
+    float windSpeed = 1.0;
+    float windStrength = noise12(offset.xz * 0.4 + vec2(uTime * windSpeed));
+    float windAngle = windStrength * 0.3 * PI;
+
+    vec2 windDir = vec2(cos(windAngle), sin(windAngle));
+
+    float leanFactor = centered.y;
+
+    // Push down influence
+    vec3 worldInstancePos = (modelMatrix * vec4(offset, 1.0)).xyz;
+    float pushInfluence = computePushInfluence(worldInstancePos);
+
+    // Apply wind + random lean + push
+    // Apply bending that increases with height
+    float heightBendFactor = pow(centered.y, 1.5); // or use `centered.y * centered.y` for similar effect
+    float bendAmount = (randomLean + windDir.x) * heightBendFactor * 0.8;
+    float pushBend = pushInfluence * leanFactor * 1.0; // Adjust strength
+
+    centered.x += bendAmount;
+    centered.z += windDir.y * leanFactor * 0.2;
+    centered.y -= pushBend; // Push downward
+
+    // Rotate and transform
+    float c = cos(rotationAngle);
+    float s = sin(rotationAngle);
+    mat3 rotationY = mat3(
+        c, 0.0, s,
+        0.0, 1.0, 0.0,
+        -s, 0.0, c
+    );
+
+    vec3 transformed = rotationY * centered + offset;
+
+    vec4 modelPosition = modelMatrix * vec4(transformed, 1.0);
+    vec4 viewPosition = viewMatrix * modelPosition;
+    gl_Position = projectionMatrix * viewPosition;
+}

package/dist/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/Prefab/Lights/index.d.ts

@@ -0,0 +1,77 @@
+import type { Light } from 'three';
+import { Object3D, Vector3 } from 'three';
+import GameObject from '../../World/GameObject';
+type UpdatableLightHelper = Object3D & {
+    update(): void;
+};
+declare const LightPrimitive_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 LightPrimitive extends LightPrimitive_base {
+    instance: Light;
+    protected lightHelper?: UpdatableLightHelper;
+    constructor(position: Vector3, light: Light, label: string);
+    protected addLightHelper(helper: UpdatableLightHelper): void;
+    update(_delta: number): void;
+    destroy(): void;
+}
+export declare class AmbientLightPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class DirectionalLightPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class DirectionalLightShadowPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class HemisphereLightPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class LightProbePrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class PointLightPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class PointLightShadowPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class RectAreaLightPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class SpotLightPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+export declare class SpotLightShadowPrimitive extends LightPrimitive {
+    constructor(position: Vector3);
+}
+declare const SceneHelperPrimitive_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;
+declare abstract class SceneHelperPrimitive extends SceneHelperPrimitive_base {
+    protected helper: Object3D;
+    constructor(position: Vector3, helper: Object3D, label: string);
+    update(_delta: number): void;
+    destroy(): void;
+}
+export declare class GridHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position: Vector3);
+}
+export declare class PolarGridHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position: Vector3);
+}
+export declare class PlaneHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position: Vector3);
+}
+export declare class SkeletonHelperPrimitive extends SceneHelperPrimitive {
+    constructor(position: Vector3);
+}
+export declare const LIGHT_REGISTRY: Record<string, new (position: Vector3) => LightPrimitive>;
+export declare const SCENE_HELPER_REGISTRY: Record<string, new (position: Vector3) => SceneHelperPrimitive>;
+export {};