@needle-tools/engine 3.2.3-alpha → 3.2.4-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.2.3-alpha",
+    "version": "3.2.4-alpha.1",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in",
     "main": "dist/needle-engine.umd.cjs",
     "type": "module",

package/plugins/vite/license.js

@@ -7,11 +7,11 @@ export const needleLicense = (command, config, userSettings) => {
         name: "needle-license",
         enforce: 'pre',
         async transform(src, id) {
-            if (id.includes("engine/engine_license.ts")) {
+            if (id.includes("engine/engine_license") || id.includes("needle-tools_engine.js")) {
                 const needleConfig = await loadConfig();
                 if (needleConfig) {
                     if (needleConfig.hasProLicense !== undefined && typeof needleConfig.hasProLicense === "boolean") {
-                        src = src.replace("const HAS_LICENSE = false;", "const HAS_LICENSE = " + needleConfig.hasProLicense + ";");
+                        src = src.replace("NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE = false;", "NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE = " + needleConfig.hasProLicense + ";");
                         return { code: src, map: null }
                     }
                 }

package/src/engine/api.ts

@@ -1,20 +1,46 @@
-export * from "./engine_constants";
-export { TypeStore } from "./engine_typestore";
-export * from "./engine_context_registry";
+
 export * from "./extensions/extensions"
-export { InstancingUtil } from "./engine_instancing";
-export * from "./engine_gameobject";
+export * from "./engine_addressables";
+export * from "./engine_application"
+export * from "./engine_assetdatabase"
+export * from "./engine_components_internal";
 export * from "./engine_components";
 export * from "./engine_components_internal";
-export { AssetReference, ImageReference } from "./engine_addressables";
-export { Context, FrameEvent } from "./engine_setup";
-export * from "./debug/debug";
-export { validate } from "./engine_util_decorator"
+export * from "./engine_context_registry"
+export * from "./engine_context";
+export * from "./engine_coroutine"
+export * from "./engine_constants";
+export * from "./debug";
+export * from "./engine_element";
 export { Gizmos } from "./engine_gizmos"
+export * from "./engine_gltf";
+export * from "./engine_hot_reload";
+export * from "./engine_gameobject";
+export * from "./engine_networking";
+export { syncField } from "./engine_networking_auto";
+export * from "./engine_networking_files";
+export * from "./engine_networking_instantiate";
+export * from "./engine_networking_utils";
+export * from "./engine_patcher"
+export * from "./engine_playerview"
+export * from "./engine_physics"
+export * from "./engine_physics.types"
+export * from "./engine_input";
+export * from "./engine_math";
+export * from "./js-extensions";
 export * from "./engine_scenetools";
-export * from "./engine_math"
-export * from "./js-extensions"
-export { hasProLicense } from "./engine_license"
+export * from "./engine_serialization";
+export * from "./engine_texture";
+export * from "./engine_time";
+export * from "./engine_types";
+export * from "./engine_utils_screenshot";
+export * from "./engine_web_api";
+
+export { TypeStore } from "./engine_typestore";
+
+export { InstancingUtil } from "./engine_instancing";
+export { validate, prefix } from "./engine_util_decorator"
+export { hasProLicense } from "./engine_license";
 
 export {
     // url params
@@ -32,11 +58,4 @@ export {
     isiOS,
     isSafari,
     isQuest,
-} from "./engine_utils";
-
-export {
-    setUsageTrackingEnabled,
-    isUsageTrackingEnabled,
-    findUsers,
-    getUserCount
-} from "./engine_assetdatabase"
+} from "./engine_utils";

package/src/engine/codegen/register_types.js

@@ -1,5 +1,5 @@
 import { TypeStore } from "./../engine_typestore"
-
+
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components";
 import { AlignmentConstraint } from "../../engine-components/AlignmentConstraint";
@@ -184,7 +184,7 @@ import { XRGrabModel } from "../../engine-components/WebXRGrabRendering";
 import { XRGrabRendering } from "../../engine-components/WebXRGrabRendering";
 import { XRRig } from "../../engine-components/WebXRRig";
 import { XRState } from "../../engine-components/XRFlag";
-
+
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("AlignmentConstraint", AlignmentConstraint);

package/src/engine/engine_addressables.ts

@@ -1,11 +1,10 @@
 import { getParam, resolveUrl } from "../engine/engine_utils";
-// import { loadSync, parseSync } from "./engine_scenetools";
 import { SerializationContext, TypeSerializer } from "./engine_serialization_core";
 import { Context } from "./engine_setup";
-import { Group, Object3D, Scene, Texture } from "three";
+import { Group, Object3D, Texture } from "three";
 import { processNewScripts } from "./engine_mainloop_utils";
 import { registerPrefabProvider, syncInstantiate } from "./engine_networking_instantiate";
-import { download, hash } from "./engine_web_api";
+import { download } from "./engine_web_api";
 import { getLoader } from "./engine_gltf";
 import { SourceIdentifier } from "./engine_types";
 import { destroy, instantiate, InstantiateOptions, isDestroyed } from "./engine_gameobject";
@@ -185,11 +184,11 @@ export class AssetReference {
         }
     }
 
-    async instantiate(parent?: THREE.Object3D | InstantiateOptions) {
+    async instantiate(parent?: Object3D | InstantiateOptions) {
         return this.onInstantiate(parent, false);
     }
 
-    async instantiateSynced(parent?: THREE.Object3D | InstantiateOptions, saveOnServer: boolean = true) {
+    async instantiateSynced(parent?: Object3D | InstantiateOptions, saveOnServer: boolean = true) {
         return this.onInstantiate(parent, true, saveOnServer);
     }
 
@@ -211,7 +210,7 @@ export class AssetReference {
         }
     }
 
-    private async onInstantiate(parent?: THREE.Object3D | InstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
+    private async onInstantiate(parent?: Object3D | InstantiateOptions, networked: boolean = false, saveOnServer?: boolean) {
         const context = Context.Current;
         if (!parent) parent = context.scene;
         if (this.mustLoad) {
@@ -282,7 +281,7 @@ export class AssetReference {
      * and call destroy on the player marker root
      * @returns the scene root object if the asset was a glb/gltf
      */
-    private tryGetActualGameObjectRoot(asset: any): THREE.Object3D | null {
+    private tryGetActualGameObjectRoot(asset: any): Object3D | null {
         if (asset && asset.scene) {
             // some exporters produce additional root objects
             const scene = asset.scene as Group;

package/src/engine/engine_context.ts

@@ -1,5 +1,8 @@
-import { Camera, Clock, DepthTexture, PerspectiveCamera, WebGLRenderer, WebGLRenderTarget } from 'three'
-import * as THREE from 'three'
+import { BufferGeometry, Camera, Clock, Color, DepthTexture, Group, 
+	Material, NearestFilter, NoToneMapping, Object3D, PCFSoftShadowMap, 
+	PerspectiveCamera, RGBAFormat, Scene, sRGBEncoding, 
+	Texture, WebGLRenderer, WebGLRenderTarget 
+} from 'three'
 import { Input } from './engine_input';
 import { Physics } from './engine_physics';
 import { Time } from './engine_time';
@@ -50,7 +53,7 @@ export class ContextArgs {
 	name?: string;
 	alias?: string;
 	domElement: HTMLElement | null;
-	renderer?: THREE.WebGLRenderer = undefined;
+	renderer?: WebGLRenderer = undefined;
 	hash?: string;
 
 	constructor(domElement: HTMLElement | null) {
@@ -74,7 +77,7 @@ export enum XRSessionMode {
 	ImmersiveAR = "immersive-ar",
 }
 
-export declare type OnBeforeRenderCallback = (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group) => void
+export declare type OnBeforeRenderCallback = (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: Group) => void
 
 
 export function registerComponent(script: IComponent, context?: Context) {
@@ -175,8 +178,8 @@ export class Context implements IContext {
 	}
 	private _currentFrameEvent: FrameEvent = FrameEvent.Undefined;
 
-	scene: THREE.Scene;
-	renderer: THREE.WebGLRenderer;
+	scene: Scene;
+	renderer: WebGLRenderer;
 	composer: EffectComposer | null = null;
 
 	// all scripts
@@ -191,7 +194,7 @@ export class Context implements IContext {
 	scripts_WithCorroutines: IComponent[] = [];
 	coroutines: { [FrameEvent: number]: Array<CoroutineData> } = {}
 
-	get mainCamera(): THREE.Camera | null {
+	get mainCamera(): Camera | null {
 		if (this.mainCameraComponent) {
 			const cam = this.mainCameraComponent as ICamera;
 			if (!cam.cam)
@@ -251,21 +254,21 @@ export class Context implements IContext {
 
 			// some tonemapping other than "NONE" is required for adjusting exposure with EXR environments
 			this.renderer.toneMappingExposure = 1; // range [0...inf] instead of the usual -15..15
-			this.renderer.toneMapping = THREE.NoToneMapping; // could also set to LinearToneMapping, ACESFilmicToneMapping
+			this.renderer.toneMapping = NoToneMapping; // could also set to LinearToneMapping, ACESFilmicToneMapping
 
-			this.renderer.setClearColor(new THREE.Color('lightgrey'), 0);
+			this.renderer.setClearColor(new Color('lightgrey'), 0);
 			// @ts-ignore
 			this.renderer.antialias = true;
 			// @ts-ignore
 			this.renderer.alpha = false;
 			this.renderer.shadowMap.enabled = true;
-			this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+			this.renderer.shadowMap.type = PCFSoftShadowMap;
 			this.renderer.setSize(this.domWidth, this.domHeight);
-			this.renderer.outputEncoding = THREE.sRGBEncoding;
+			this.renderer.outputEncoding = sRGBEncoding;
 			this.renderer.physicallyCorrectLights = true;
 		}
 
-		this.scene = new THREE.Scene();
+		this.scene = new Scene();
 
 		ContextRegistry.register(this);
 
@@ -328,7 +331,7 @@ export class Context implements IContext {
 		}
 	}
 
-	updateAspect(camera: THREE.PerspectiveCamera, width?: number, height?: number) {
+	updateAspect(camera: PerspectiveCamera, width?: number, height?: number) {
 		if (!camera) return;
 		if (width === undefined)
 			width = this.domWidth;
@@ -410,7 +413,7 @@ export class Context implements IContext {
 		if (index >= 0) this._cameraStack.splice(index, 1);
 		this._cameraStack.push(cam);
 		this.mainCameraComponent = cam;
-		const camera = cam.cam as THREE.PerspectiveCamera;
+		const camera = cam.cam as PerspectiveCamera;
 		if (camera.isPerspectiveCamera)
 			this.updateAspect(camera);
 		(this.mainCameraComponent as ICamera)?.applyClearFlagsIfIsActiveCamera();
@@ -434,7 +437,7 @@ export class Context implements IContext {
 	private _onBeforeRenderListeners: { [key: string]: OnBeforeRenderCallback[] } = {};
 
 	/** use this to subscribe to onBeforeRender events on threejs objects */
-	addBeforeRenderListener(target: THREE.Object3D, callback: OnBeforeRenderCallback) {
+	addBeforeRenderListener(target: Object3D, callback: OnBeforeRenderCallback) {
 		if (!this._onBeforeRenderListeners[target.uuid]) {
 			this._onBeforeRenderListeners[target.uuid] = [];
 			const onBeforeRenderCallback = (renderer, scene, camera, geometry, material, group) => {
@@ -450,7 +453,7 @@ export class Context implements IContext {
 		this._onBeforeRenderListeners[target.uuid].push(callback);
 	}
 
-	removeBeforeRenderListener(target: THREE.Object3D, callback: OnBeforeRenderCallback) {
+	removeBeforeRenderListener(target: Object3D, callback: OnBeforeRenderCallback) {
 		if (this._onBeforeRenderListeners[target.uuid]) {
 			const arr = this._onBeforeRenderListeners[target.uuid];
 			const idx = arr.indexOf(callback);
@@ -473,11 +476,11 @@ export class Context implements IContext {
 		this._requireColorTexture = val;
 	}
 
-	get depthTexture(): THREE.DepthTexture | null {
+	get depthTexture(): DepthTexture | null {
 		return this._renderTarget?.depthTexture || null;
 	}
 
-	get opaqueColorTexture(): THREE.Texture | null {
+	get opaqueColorTexture(): Texture | null {
 		return this._renderTarget?.texture || null;
 	}
 
@@ -822,17 +825,17 @@ export class Context implements IContext {
 		if (!this.mainCamera) return;
 		if (!this._requireDepthTexture && !this._requireColorTexture) return;
 		if (!this._renderTarget) {
-			this._renderTarget = new THREE.WebGLRenderTarget(this.domWidth, this.domHeight);
+			this._renderTarget = new WebGLRenderTarget(this.domWidth, this.domHeight);
 			if (this._requireDepthTexture) {
 				const dt = new DepthTexture(this.domWidth, this.domHeight);;
 				this._renderTarget.depthTexture = dt;
 			}
 			if (this._requireColorTexture) {
-				this._renderTarget.texture = new THREE.Texture();
+				this._renderTarget.texture = new Texture();
 				this._renderTarget.texture.generateMipmaps = false;
-				this._renderTarget.texture.minFilter = THREE.NearestFilter;
-				this._renderTarget.texture.magFilter = THREE.NearestFilter;
-				this._renderTarget.texture.format = THREE.RGBAFormat;
+				this._renderTarget.texture.minFilter = NearestFilter;
+				this._renderTarget.texture.magFilter = NearestFilter;
+				this._renderTarget.texture.format = RGBAFormat;
 			}
 		}
 		const rt = this._renderTarget;
@@ -909,24 +912,24 @@ export class Context implements IContext {
 }
 
 
-// const scene = new THREE.Scene();
+// const scene = new Scene();
 // const useComposer = utils.getParam("postfx");
 // const renderer = new WebGLRenderer({ antialias: true });
 // const composer = useComposer ? new EffectComposer(renderer) : undefined;
 
-// renderer.setClearColor(new THREE.Color('lightgrey'), 0)
+// renderer.setClearColor(new Color('lightgrey'), 0)
 // renderer.antialias = true;
 // renderer.alpha = false;
 // renderer.shadowMap.enabled = true;
-// renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+// renderer.shadowMap.type = PCFSoftShadowMap;
 // renderer.setSize(window.innerWidth, window.innerHeight);
-// renderer.outputEncoding = THREE.sRGBEncoding;
+// renderer.outputEncoding = sRGBEncoding;
 // renderer.physicallyCorrectLights = true;
 // document.body.appendChild(renderer.domElement);
 
 // // generation pushes loading requests in this array
 // const sceneData: {
-//     mainCamera: THREE.Camera | undefined
+//     mainCamera: Camera | undefined
 // } = {
 //     preparing: [],
 //     resolving: [],

package/src/engine/engine_fileloader.js

@@ -1,6 +1,6 @@
-import * as THREE from "three";
+import { FileLoader } from "three";
 
-export const loader = new THREE.FileLoader();
+export const loader = new FileLoader();
 
 export async function loadFileAsync(url) {
   return new Promise((resolve, reject) => {

package/src/engine/engine_gameobject.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, InstancedBufferGeometry, Material, Mesh, Object3D, Texture } from "three";
+import { Bone, Object3D, Quaternion, SkinnedMesh, Vector3 } from "three";
 import { processNewScripts } from "./engine_mainloop_utils";
 import { InstantiateIdProvider } from "./engine_networking_instantiate";
 import { Context, registerComponent } from "./engine_setup";
@@ -36,9 +36,9 @@ export class InstantiateOptions {
     parent?: string | undefined | Object3D;
     /** for duplicatable parenting */
     keepWorldPosition?: boolean
-    position?: THREE.Vector3 | undefined;
-    rotation?: THREE.Quaternion | undefined;
-    scale?: THREE.Vector3 | undefined;
+    position?: Vector3 | undefined;
+    rotation?: Quaternion | undefined;
+    scale?: Vector3 | undefined;
 
     visible?: boolean | undefined;
 
@@ -88,14 +88,14 @@ export function isActiveInHierarchy(go: Object3D): boolean {
     return go[activeInHierarchyFieldName] || isUsingInstancing(go);
 }
 
-export function markAsInstancedRendered(go: THREE.Object3D, instanced: boolean) {
+export function markAsInstancedRendered(go: Object3D, instanced: boolean) {
     go[$isUsingInstancing] = instanced;
 }
 
-export function isUsingInstancing(instance: THREE.Object3D): boolean { return InstancingUtil.isUsingInstancing(instance); }
+export function isUsingInstancing(instance: Object3D): boolean { return InstancingUtil.isUsingInstancing(instance); }
 
 
-export function findByGuid(guid: string, hierarchy: THREE.Object3D): GameObject | IComponent | null | undefined {
+export function findByGuid(guid: string, hierarchy: Object3D): GameObject | IComponent | null | undefined {
     return tryFindObject(guid, hierarchy, true, true);
 }
 
@@ -159,7 +159,7 @@ function internalDestroy(instance: Object3D | Component, recursive: boolean = tr
 
 declare type ForEachComponentCallback = (comp: Component) => any;
 
-export function foreachComponent(instance: THREE.Object3D, cb: ForEachComponentCallback, recursive: boolean = true): any {
+export function foreachComponent(instance: Object3D, cb: ForEachComponentCallback, recursive: boolean = true): any {
     return internalForEachComponent(instance, cb, recursive);
 }
 
@@ -198,8 +198,8 @@ function internalForEachComponent(instance: Object3D, cb: ForEachComponentCallba
 }
 
 declare class NewGameObjectReferenceInfo {
-    original: THREE.Object3D;
-    clone: THREE.Object3D;
+    original: Object3D;
+    clone: Object3D;
 }
 
 export function instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
@@ -210,7 +210,7 @@ export function instantiate(instance: GameObject | Object3D | null, opts: Instan
         // if x is defined assume this is a vec3 - this is just to not break everything at once and stay a little bit backwards compatible
         if (opts["x"] !== undefined) {
             options = new InstantiateOptions();
-            options.position = opts as unknown as THREE.Vector3;
+            options.position = opts as unknown as Vector3;
         }
         else {
             // if (opts instanceof InstantiateOptions)
@@ -276,12 +276,12 @@ export function instantiate(instance: GameObject | Object3D | null, opts: Instan
 
 
 function internalInstantiate(
-    context: Context, instance: GameObject | THREE.Object3D, opts: InstantiateOptions | null,
+    context: Context, instance: GameObject | Object3D, opts: InstantiateOptions | null,
     componentsList: Array<Component>,
     newGameObjectsMap: { [key: string]: NewGameObjectReferenceInfo },
     skinnedMeshesMap: { [key: string]: NewGameObjectReferenceInfo }
 )
-    : GameObject | THREE.Object3D | null {
+    : GameObject | Object3D | null {
     if (!instance) return null;
     // prepare, remove things that dont work out of the box
     // e.g. user data we want to manually clone
@@ -290,7 +290,7 @@ function internalInstantiate(
     instance.userData = {};
     const children = instance.children;
     instance.children = [];
-    let clone: THREE.Object3D | GameObject;
+    let clone: Object3D | GameObject;
     clone = instance.clone(false);
     apply(clone);
     // if(instance[$originalGuid])
@@ -408,9 +408,9 @@ function resolveAndBindSkinnedMeshBones(
 ) {
     for (const key in skinnedMeshes) {
         const val = skinnedMeshes[key];
-        const original = val.original as THREE.SkinnedMesh;
+        const original = val.original as SkinnedMesh;
         const originalSkeleton = original.skeleton;
-        const clone = val.clone as THREE.SkinnedMesh;
+        const clone = val.clone as SkinnedMesh;
         // clone.updateWorldMatrix(true, true);
         if (!originalSkeleton) {
             console.warn("Skinned mesh has no skeleton?", val);
@@ -426,16 +426,16 @@ function resolveAndBindSkinnedMeshBones(
         // clone.bindMatrix.multiplyScalar(.025);
         // console.assert(originalSkeleton.uuid !== clonedSkeleton.uuid);
         // console.assert(originalBones.length === clonedSkeleton.bones.length);
-        const bones: Array<THREE.Bone> = [];
+        const bones: Array<Bone> = [];
         clonedSkeleton.bones = bones;
         for (let i = 0; i < originalBones.length; i++) {
             const bone = originalBones[i];
             const newBoneInfo = newObjectsMap[bone.uuid];
-            const clonedBone = newBoneInfo.clone as THREE.Bone;
+            const clonedBone = newBoneInfo.clone as Bone;
             // console.log("NEW BONE: ", clonedBone, "BEFORE", newBoneInfo.original);
             bones.push(clonedBone);
         }
-        // clone.skeleton = new THREE.Skeleton(bones);
+        // clone.skeleton = new Skeleton(bones);
         // clone.skeleton.update();
         // clone.pose();
         // clone.scale.set(1,1,1);
@@ -443,7 +443,7 @@ function resolveAndBindSkinnedMeshBones(
         // console.log("ORIG", original, "CLONE", clone);
     }
     for (const key in skinnedMeshes) {
-        const clone = skinnedMeshes[key].clone as THREE.SkinnedMesh;
+        const clone = skinnedMeshes[key].clone as SkinnedMesh;
         clone.skeleton.update();
         // clone.skeleton.calculateInverses();
         clone.bind(clone.skeleton, clone.bindMatrix);
@@ -532,7 +532,7 @@ function resolveReferences(newObjectsMap: { [key: string]: NewGameObjectReferenc
 
 }
 
-function postProcessNewInstance(copy: THREE.Object3D, key: string, value: IComponent | Object3D | any, newObjectsMap: { [key: string]: NewGameObjectReferenceInfo }) {
+function postProcessNewInstance(copy: Object3D, key: string, value: IComponent | Object3D | any, newObjectsMap: { [key: string]: NewGameObjectReferenceInfo }) {
     if (value === null || value === undefined) return;
     if ((value as IComponent).isComponent === true) {
         const originalGameObjectReference = value["gameObject"];

package/src/engine/engine_gizmos.ts

@@ -1,7 +1,6 @@
-import * as THREE from 'three';
 import { BufferAttribute, Line, BoxGeometry, EdgesGeometry, Color, LineSegments, LineBasicMaterial, Object3D, Mesh, SphereGeometry, ColorRepresentation, Vector3, Box3, Quaternion, CylinderGeometry } from 'three';
 import { Context } from './engine_setup';
-import { setWorldPosition, setWorldPositionXYZ } from './engine_three_utils';
+import { setWorldPositionXYZ } from './engine_three_utils';
 import { Vec3, Vec4 } from './engine_types';
 
 const _tmp = new Vector3();
@@ -109,12 +108,12 @@ export class Gizmos {
 }
 
 const box: BoxGeometry = new BoxGeometry(1, 1, 1);
-export function CreateWireCube(col: THREE.ColorRepresentation | null = null): THREE.LineSegments {
+export function CreateWireCube(col: ColorRepresentation | null = null): LineSegments {
     const color = new Color(col ?? 0xdddddd);
-    // const material = new THREE.MeshBasicMaterial();
-    // material.color = new THREE.Color(col ?? 0xdddddd);
+    // const material = new MeshBasicMaterial();
+    // material.color = new Color(col ?? 0xdddddd);
     // material.wireframe = true;
-    // const box = new THREE.Mesh(box, material);
+    // const box = new Mesh(box, material);
     // box.name = "BOX_GIZMO";
     const edges = new EdgesGeometry(box);
     const line = new LineSegments(edges, new LineBasicMaterial({ color: color }));

package/src/engine/engine_gltf_builtin_components.ts

@@ -1,7 +1,5 @@
 import "./codegen/register_types";
 import { TypeStore } from "./engine_typestore";
-import * as THREE from "three";
-// import { GameObject } from "../engine-components/Component";
 import { InstantiateIdProvider } from "./engine_networking_instantiate"
 import { Context } from "./engine_setup";
 import { deserializeObject, serializeObject } from "./engine_serialization";
@@ -15,6 +13,7 @@ import { addNewComponent } from "./engine_components";
 import { getParam } from "./engine_utils";
 import { LogType, showBalloonMessage } from "./debug/debug";
 import { isLocalNetwork } from "./engine_networking_utils";
+import { Object3D } from "three";
 
 
 const debug = debugExtension;
@@ -43,7 +42,7 @@ const $context_deserialize_queue = Symbol("deserialize-queue");
 
 export async function createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf, seed: number | null | UIDProvider = null, extension?: NEEDLE_components) {
     if (!gltf) return;
-    const lateResolve: Array<(gltf: THREE.Object3D) => {}> = [];
+    const lateResolve: Array<(gltf: Object3D) => {}> = [];
 
     let idProvider: UIDProvider | null = seed as UIDProvider;
     if (typeof idProvider === "number") {
@@ -145,15 +144,15 @@ declare interface IGltfBuiltinComponentData {
 declare class DeserializeData {
     instance: any;
     compData: IGltfbuiltinComponent;
-    obj: THREE.Object3D;
+    obj: Object3D;
 }
 
-declare type LateResolveCallback = (gltf: THREE.Object3D) => void;
+declare type LateResolveCallback = (gltf: Object3D) => void;
 
 const unknownComponentsBuffer: Array<string> = [];
 
 
-async function onCreateBuiltinComponents(context: SerializationContext, obj: THREE.Object3D,
+async function onCreateBuiltinComponents(context: SerializationContext, obj: Object3D,
     deserialize: DeserializeData[], lateResolve: LateResolveCallback[]) {
     if (!obj) return;
 
@@ -324,13 +323,13 @@ function handleDeserialization(data: DeserializeData, context: SerializationCont
 // function tryResolveType(type, entry): any | undefined {
 //     switch (type) {
 //         case "Vector2":
-//             return new THREE.Vector2(entry.x, entry.y);
+//             return new Vector2(entry.x, entry.y);
 //         case "Vector3":
-//             return new THREE.Vector3(entry.x, entry.y, entry.z);
+//             return new Vector3(entry.x, entry.y, entry.z);
 //         case "Vector4":
-//             return new THREE.Vector4(entry.x, entry.y, entry.z, entry.w);
+//             return new Vector4(entry.x, entry.y, entry.z, entry.w);
 //         case "Quaternion":
-//             return new THREE.Quaternion(entry.x, entry.y, entry.z, entry.w);
+//             return new Quaternion(entry.x, entry.y, entry.z, entry.w);
 //     }
 //     return undefined;
 // }

package/src/engine/engine_input.ts

@@ -1,4 +1,3 @@
-import * as THREE from 'three';
 import { Vector2 } from 'three';
 import { showBalloonMessage, showBalloonWarning } from './debug/debug';
 import { assign } from './engine_serialization_core';
@@ -58,8 +57,8 @@ export class Input extends EventTarget {
     _doubleClickTimeThreshold = .2;
     _longPressTimeThreshold = 1;
 
-    get mousePosition(): THREE.Vector2 { return this._pointerPositions[0]; };
-    get mousePositionRC(): THREE.Vector2 { return this._pointerPositionsRC[0]; }
+    get mousePosition(): Vector2 { return this._pointerPositions[0]; };
+    get mousePositionRC(): Vector2 { return this._pointerPositionsRC[0]; }
     get mouseDown(): boolean { return this._pointerDown[0]; }
     get mouseUp(): boolean { return this._pointerUp[0]; }
     get mouseClick(): boolean { return this._pointerClick[0]; }
@@ -91,19 +90,19 @@ export class Input extends EventTarget {
         return count;
     }
 
-    getPointerPosition(i: number): THREE.Vector2 | null {
+    getPointerPosition(i: number): Vector2 | null {
         if (i >= this._pointerPositions.length) return null;
         return this._pointerPositions[i];
     }
-    getPointerPositionLastFrame(i: number): THREE.Vector2 | null {
+    getPointerPositionLastFrame(i: number): Vector2 | null {
         if (i >= this._pointerPositionsLastFrame.length) return null;
         return this._pointerPositionsLastFrame[i];
     }
-    getPointerPositionDelta(i: number): THREE.Vector2 | null {
+    getPointerPositionDelta(i: number): Vector2 | null {
         if (i >= this._pointerPositionsDelta.length) return null;
         return this._pointerPositionsDelta[i];
     }
-    getPointerPositionRC(i: number): THREE.Vector2 | null {
+    getPointerPositionRC(i: number): Vector2 | null {
         if (i >= this._pointerPositionsRC.length) return null;
         return this._pointerPositionsRC[i];
     }
@@ -213,11 +212,11 @@ export class Input extends EventTarget {
     private _pointerClick: boolean[] = [false];
     private _pointerDoubleClick: boolean[] = [false];
     private _pointerPressed: boolean[] = [false];
-    private _pointerPositions: THREE.Vector2[] = [new THREE.Vector2()];
-    private _pointerPositionsLastFrame: THREE.Vector2[] = [new THREE.Vector2()];
-    private _pointerPositionsDelta: THREE.Vector2[] = [new THREE.Vector2()];
-    private _pointerPositionsRC: THREE.Vector2[] = [new THREE.Vector2()];
-    private _pointerPositionDown: THREE.Vector2[] = [new THREE.Vector2()];
+    private _pointerPositions: Vector2[] = [new Vector2()];
+    private _pointerPositionsLastFrame: Vector2[] = [new Vector2()];
+    private _pointerPositionsDelta: Vector2[] = [new Vector2()];
+    private _pointerPositionsRC: Vector2[] = [new Vector2()];
+    private _pointerPositionDown: Vector2[] = [new Vector2()];
     private _pointerDownTime: number[] = [];
     private _pointerUpTime: number[] = [];
     private _pointerUpTimestamp: number[] = [];
@@ -505,9 +504,9 @@ export class Input extends EventTarget {
         while (evt.button >= this._pointerTypes.length) this._pointerTypes.push(evt.pointerType);
         this._pointerTypes[evt.button] = evt.pointerType;
 
-        while (evt.button >= this._pointerPositionDown.length) this._pointerPositionDown.push(new THREE.Vector2());
+        while (evt.button >= this._pointerPositionDown.length) this._pointerPositionDown.push(new Vector2());
         this._pointerPositionDown[evt.button].set(evt.clientX, evt.clientY);
-        while (evt.button >= this._pointerPositions.length) this._pointerPositions.push(new THREE.Vector2());
+        while (evt.button >= this._pointerPositions.length) this._pointerPositions.push(new Vector2());
         this._pointerPositions[evt.button].set(evt.clientX, evt.clientY);
 
         if (evt.button >= this._pointerDownTime.length) this._pointerDownTime.push(0);
@@ -577,9 +576,9 @@ export class Input extends EventTarget {
 
     private updatePointerPosition(evt: PointerEventArgs) {
         // console.log("MOVE");
-        while (evt.button >= this._pointerPositions.length) this._pointerPositions.push(new THREE.Vector2());
-        while (evt.button >= this._pointerPositionsLastFrame.length) this._pointerPositionsLastFrame.push(new THREE.Vector2());
-        while (evt.button >= this._pointerPositionsDelta.length) this._pointerPositionsDelta.push(new THREE.Vector2());
+        while (evt.button >= this._pointerPositions.length) this._pointerPositions.push(new Vector2());
+        while (evt.button >= this._pointerPositionsLastFrame.length) this._pointerPositionsLastFrame.push(new Vector2());
+        while (evt.button >= this._pointerPositionsDelta.length) this._pointerPositionsDelta.push(new Vector2());
 
         const lf = this._pointerPositionsLastFrame[evt.button];
         lf.copy(this._pointerPositions[evt.button]);
@@ -593,7 +592,7 @@ export class Input extends EventTarget {
         // we want to have the position 01 on the canvas for raycasting
         const px = evt.clientX;
         const py = evt.clientY;
-        while (evt.button >= this._pointerPositionsRC.length) this._pointerPositionsRC.push(new THREE.Vector2());
+        while (evt.button >= this._pointerPositionsRC.length) this._pointerPositionsRC.push(new Vector2());
         const rc = this._pointerPositionsRC[evt.button];
         rc.set(px, py);
         this.convertScreenspaceToRaycastSpace(rc);