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

package/src/engine/engine_license.ts

@@ -7,10 +7,10 @@ const debug = getParam("debuglicense");
 
 // This is modified by a bundler (e.g. vite)
 // Do not edit manually
-const HAS_LICENSE = false;
+const NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE = false;
 
 export function hasProLicense() {
-    return HAS_LICENSE;
+    return NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE;
 }
 
 

package/src/engine/engine_mainloop_utils.ts

@@ -230,7 +230,7 @@ export function updateIsActive(obj?: Object3D) {
     }
 }
 
-function updateIsActiveInHierarchyRecursiveRuntime(go: THREE.Object3D, activeInHierarchy: boolean, allowEventCall: boolean, level: number = 0) {
+function updateIsActiveInHierarchyRecursiveRuntime(go: Object3D, activeInHierarchy: boolean, allowEventCall: boolean, level: number = 0) {
     if (level > 1000) {
         console.warn("Hierarchy is too deep (> 1000 level) - will abort updating active state");
         return false;
@@ -307,7 +307,7 @@ function updateIsActiveInHierarchyRecursiveRuntime(go: THREE.Object3D, activeInH
 
 // let isRunning = false;
 // // Prevent: https://github.com/needle-tools/needle-tiny/issues/641
-// const temporyChildArrayBuffer: Array<Array<THREE.Object3D>> = [];
+// const temporyChildArrayBuffer: Array<Array<Object3D>> = [];
 // export function* iterateChildrenSafe(obj: Object3D) {
 //     if (!obj || !obj.children) yield null;
 //     // if(isRunning) return;
@@ -322,9 +322,9 @@ function updateIsActiveInHierarchyRecursiveRuntime(go: THREE.Object3D, activeInH
 //     temporyChildArrayBuffer.push(arr);
 // }
 
-export function updateActiveInHierarchyWithoutEventCall(go: THREE.Object3D) {
+export function updateActiveInHierarchyWithoutEventCall(go: Object3D) {
     let activeInHierarchy = true;
-    let current: THREE.Object3D | null = go;
+    let current: Object3D | null = go;
     let foundScene: boolean = false;
     while (current) {
         if (!current) break;
@@ -342,7 +342,7 @@ export function updateActiveInHierarchyWithoutEventCall(go: THREE.Object3D) {
     go[constants.activeInHierarchyFieldName] = activeInHierarchy && foundScene;
 }
 
-function perComponent(go: THREE.Object3D, evt: (comp: IComponent) => void) {
+function perComponent(go: Object3D, evt: (comp: IComponent) => void) {
     if (go.userData?.components) {
         for (const comp of go.userData.components) {
             evt(comp);

package/src/engine/engine_networking_auto.ts

@@ -210,7 +210,7 @@ export declare type FieldChangedCallbackFn = (newValue: any, previousValue: any)
  * (for example a networked color is sent as a number and may be converted to a color in the receiver again)
  * Parameters: (newValue, previousValue)
  */
-export const syncField = function(onFieldChanged: string | FieldChangedCallbackFn) {
+export const syncField = function(onFieldChanged?: string | FieldChangedCallbackFn) {
 
     return function (target: any, propertyKey: string) {
 

package/src/engine/engine_networking_files.ts

@@ -1,6 +1,4 @@
 import { Context } from "../engine/engine_setup";
-// import { loadSync, parseSync } from "../engine/engine_scenetools";
-import * as THREE from "three";
 import * as web from "../engine/engine_web_api";
 import { NetworkConnection } from "../engine/engine_networking";
 import { generateSeed, InstantiateIdProvider } from "../engine/engine_networking_instantiate";
@@ -11,6 +9,7 @@ import { IModel } from "./engine_networking_types";
 import { IGameObject } from "./engine_types";
 import { findByGuid } from "./engine_gameobject";
 import { ContextEvent, ContextRegistry } from "./engine_context_registry";
+import { BoxGeometry, BoxHelper, Mesh, MeshBasicMaterial, Object3D, Vector3 } from "three";
 
 export enum File_Event {
     File_Spawned = "file-spawned",
@@ -21,15 +20,15 @@ export class FileSpawnModel implements IModel {
     file_name: string;
     file_hash: string;
     file_size: number;
-    position: THREE.Vector3 | null;
+    position: Vector3 | null;
     seed: number;
     sender: string;
     serverUrl: string;
     parentGuid?: string;
 
-    boundsSize?: THREE.Vector3;
+    boundsSize?: Vector3;
 
-    constructor(connectionId: string, seed: number, guid: string, name: string, hash: string, size: number, position: THREE.Vector3 | null, serverUrl: string) {
+    constructor(connectionId: string, seed: number, guid: string, name: string, hash: string, size: number, position: Vector3 | null, serverUrl: string) {
         this.seed = seed;
         this.guid = guid;
         this.file_name = name;
@@ -129,7 +128,7 @@ export function beginListenFileSpawn(context: Context) {
 
                     // add object to proper parent
                     if (evt.parentGuid) {
-                        const parent = findByGuid(evt.parentGuid, context.scene) as THREE.Object3D;
+                        const parent = findByGuid(evt.parentGuid, context.scene) as Object3D;
                         if ("add" in parent) parent.add(obj);
                     }
                     if (!obj.parent)
@@ -182,16 +181,16 @@ async function handleUpload(connection: NetworkConnection, file: File, seed: num
 }
 
 
-const previews: { [key: string]: THREE.Object3D } = {};
+const previews: { [key: string]: Object3D } = {};
 
 function addPreview(evt: FileSpawnModel, context: Context) {
-    const sphere = new THREE.BoxGeometry();
-    const object = new THREE.Mesh(sphere, new THREE.MeshBasicMaterial({ color: 0x00ff00 }));
-    const box = new THREE.BoxHelper(object, 0x555555);
+    const sphere = new BoxGeometry();
+    const object = new Mesh(sphere, new MeshBasicMaterial({ color: 0x00ff00 }));
+    const box = new BoxHelper(object, 0x555555);
     previews[evt.guid] = box;
     context.scene.add(box);
     if (evt.parentGuid) {
-        const parent = findByGuid(evt.parentGuid, context.scene) as THREE.Object3D;
+        const parent = findByGuid(evt.parentGuid, context.scene) as Object3D;
         if (parent)
             parent.add(box);
     }

package/src/engine/engine_three_utils.ts

@@ -1,6 +1,6 @@
 import * as THREE from "three";
 import { Mathf } from "./engine_math"
-import { WebGLRenderer, Vector3, Quaternion, Uniform, Texture, Material, ShaderMaterial, CanvasTexture, AnimationAction, Camera, PerspectiveCamera } from "three";
+import { WebGLRenderer, Vector3, Quaternion, Uniform, Texture, Material, ShaderMaterial, CanvasTexture, AnimationAction, Camera, PerspectiveCamera, Object3D, Euler, PlaneGeometry, Scene, Mesh } from "three";
 import { CircularBuffer } from "./engine_utils";
 
 
@@ -12,16 +12,16 @@ export function slerp(vec: Vector3, end: Vector3, t: number) {
 }
 
 const flipYQuat: Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI);
-export function lookAtInverse(obj: THREE.Object3D, target: Vector3) {
+export function lookAtInverse(obj: Object3D, target: Vector3) {
 
     obj.lookAt(target);
     obj.quaternion.multiply(flipYQuat);
 }
 
 
-const _worldPositions = new CircularBuffer(() => new THREE.Vector3(), 100);
+const _worldPositions = new CircularBuffer(() => new Vector3(), 100);
 
-export function getWorldPosition(obj: THREE.Object3D, vec: THREE.Vector3 | null = null, updateParents: boolean = true): THREE.Vector3 {
+export function getWorldPosition(obj: Object3D, vec: Vector3 | null = null, updateParents: boolean = true): Vector3 {
     const wp = vec ?? _worldPositions.get();
     if (!obj) return wp.set(0, 0, 0);
     if (!obj.parent) return wp.copy(obj.position);
@@ -33,7 +33,7 @@ export function getWorldPosition(obj: THREE.Object3D, vec: THREE.Vector3 | null
     return wp;
 }
 
-export function setWorldPosition(obj: THREE.Object3D, val: THREE.Vector3) {
+export function setWorldPosition(obj: Object3D, val: Vector3) {
     if (!obj) return;
     const wp = _worldPositions.get();
     if (val !== wp)
@@ -43,25 +43,25 @@ export function setWorldPosition(obj: THREE.Object3D, val: THREE.Vector3) {
     obj.position.set(wp.x, wp.y, wp.z);
 }
 
-export function setWorldPositionXYZ(obj: THREE.Object3D, x: number, y: number, z: number) {
+export function setWorldPositionXYZ(obj: Object3D, x: number, y: number, z: number) {
     const wp = _worldPositions.get();
     wp.set(x, y, z);
     setWorldPosition(obj, wp);
 }
 
 
-const _worldQuaternionBuffer: THREE.Quaternion = new THREE.Quaternion();
-const _worldQuaternion: THREE.Quaternion = new THREE.Quaternion();
-const _tempQuaternionBuffer2: THREE.Quaternion = new THREE.Quaternion();
+const _worldQuaternionBuffer: Quaternion = new Quaternion();
+const _worldQuaternion: Quaternion = new Quaternion();
+const _tempQuaternionBuffer2: Quaternion = new Quaternion();
 
-export function getWorldQuaternion(obj: THREE.Object3D, target: THREE.Quaternion | null = null): THREE.Quaternion {
+export function getWorldQuaternion(obj: Object3D, target: Quaternion | null = null): Quaternion {
     if (!obj) return _worldQuaternion.set(0, 0, 0, 1);
     const quat = target ?? _worldQuaternion;
     if (!obj.parent) return quat.copy(obj.quaternion);
     obj.getWorldQuaternion(quat);
     return quat;
 }
-export function setWorldQuaternion(obj: THREE.Object3D, val: THREE.Quaternion) {
+export function setWorldQuaternion(obj: Object3D, val: Quaternion) {
     if (!obj) return;
     if (val !== _worldQuaternionBuffer)
         _worldQuaternionBuffer.copy(val);
@@ -74,22 +74,22 @@ export function setWorldQuaternion(obj: THREE.Object3D, val: THREE.Quaternion) {
     obj.quaternion.set(q.x, q.y, q.z, q.w);
     // console.error("quaternion world to local is not yet implemented");
 }
-export function setWorldQuaternionXYZW(obj: THREE.Object3D, x: number, y: number, z: number, w: number) {
+export function setWorldQuaternionXYZW(obj: Object3D, x: number, y: number, z: number, w: number) {
     _worldQuaternionBuffer.set(x, y, z, w);
     setWorldQuaternion(obj, _worldQuaternionBuffer);
 }
 
-const _worldScale: THREE.Vector3 = new THREE.Vector3();
-const _worldScale2: THREE.Vector3 = new THREE.Vector3();
+const _worldScale: Vector3 = new Vector3();
+const _worldScale2: Vector3 = new Vector3();
 
-export function getWorldScale(obj: THREE.Object3D, vec: THREE.Vector3 | null = null): THREE.Vector3 {
+export function getWorldScale(obj: Object3D, vec: Vector3 | null = null): Vector3 {
     if (!obj) return _worldScale.set(0, 0, 0);
     if (!obj.parent) return _worldScale.copy(obj.scale);
     obj.getWorldScale(vec ?? _worldScale);
     return vec ?? _worldScale;
 }
 
-export function setWorldScale(obj: THREE.Object3D, vec: THREE.Vector3) {
+export function setWorldScale(obj: Object3D, vec: Vector3) {
     if (!obj) return;
     if (!obj.parent) {
         obj.scale.copy(vec);
@@ -102,35 +102,35 @@ export function setWorldScale(obj: THREE.Object3D, vec: THREE.Vector3) {
     obj.scale.copy(tempVec);
 }
 
-const _forward = new THREE.Vector3();
-const _forwardQuat = new THREE.Quaternion();
-export function forward(obj: THREE.Object3D): THREE.Vector3 {
+const _forward = new Vector3();
+const _forwardQuat = new Quaternion();
+export function forward(obj: Object3D): Vector3 {
     getWorldQuaternion(obj, _forwardQuat);
     return _forward.set(0, 0, 1).applyQuaternion(_forwardQuat);
 }
 
 
 
-const _worldEulerBuffer: THREE.Euler = new THREE.Euler();
-const _worldEuler: THREE.Euler = new THREE.Euler();
-const _worldRotation: THREE.Vector3 = new THREE.Vector3();
+const _worldEulerBuffer: Euler = new Euler();
+const _worldEuler: Euler = new Euler();
+const _worldRotation: Vector3 = new Vector3();
 
 
 
 // world euler (in radians)
-export function getWorldEuler(obj: THREE.Object3D): THREE.Euler {
+export function getWorldEuler(obj: Object3D): Euler {
     obj.getWorldQuaternion(_worldQuaternion);
     _worldEuler.setFromQuaternion(_worldQuaternion);
     return _worldEuler;
 }
 
 // world euler (in radians)
-export function setWorldEuler(obj: THREE.Object3D, val: THREE.Euler) {
+export function setWorldEuler(obj: Object3D, val: Euler) {
     setWorldQuaternion(obj, _worldQuaternion.setFromEuler(val));;
 }
 
 // returns rotation in degrees
-export function getWorldRotation(obj: THREE.Object3D): THREE.Vector3 {
+export function getWorldRotation(obj: Object3D): Vector3 {
     const rot = getWorldEuler(obj);
     const wr = _worldRotation;
     wr.set(rot.x, rot.y, rot.z);
@@ -140,11 +140,11 @@ export function getWorldRotation(obj: THREE.Object3D): THREE.Vector3 {
     return wr;
 }
 
-export function setWorldRotation(obj: THREE.Object3D, val: THREE.Vector3) {
+export function setWorldRotation(obj: Object3D, val: Vector3) {
     setWorldRotationXYZ(obj, val.x, val.y, val.z, true);
 }
 
-export function setWorldRotationXYZ(obj: THREE.Object3D, x: number, y: number, z: number, degrees: boolean = true) {
+export function setWorldRotationXYZ(obj: Object3D, x: number, y: number, z: number, degrees: boolean = true) {
     if (degrees) {
         x = Mathf.toRadians(x);
         y = Mathf.toRadians(y);
@@ -159,18 +159,18 @@ export function setWorldRotationXYZ(obj: THREE.Object3D, x: number, y: number, z
 
 
 
-// from https://github.com/mrdoob/three.js/pull/10995#issuecomment-287614722
-export function logHierarchy(root: THREE.Object3D | null | undefined, collapsible: boolean = true) {
+// from https://github.com/mrdoob/js/pull/10995#issuecomment-287614722
+export function logHierarchy(root: Object3D | null | undefined, collapsible: boolean = true) {
     if (!root) return;
     if (collapsible) {
-        (function printGraph(obj: THREE.Object3D) {
+        (function printGraph(obj: Object3D) {
             console.groupCollapsed((obj.name ? obj.name : '(no name : ' + obj.type + ')') + ' %o', obj);
             obj.children.forEach(printGraph);
             console.groupEnd();
         }(root));
 
     } else {
-        root.traverse(function (obj: THREE.Object3D) {
+        root.traverse(function (obj: Object3D) {
             var s = '|___';
             var obj2 = obj;
             while (obj2.parent !== null) {
@@ -198,10 +198,10 @@ export function isAnimationAction(obj: object) {
 
 
 export class Graphics {
-    private static planeGeometry = new THREE.PlaneGeometry(2, 2, 1, 1);
+    private static planeGeometry = new PlaneGeometry(2, 2, 1, 1);
     private static renderer = new WebGLRenderer({ antialias: false });
-    private static perspectiveCam = new THREE.PerspectiveCamera();
-    private static scene = new THREE.Scene();
+    private static perspectiveCam = new PerspectiveCamera();
+    private static scene = new Scene();
     private static readonly vertex = `
     varying vec2 vUv;
     void main(){
@@ -230,7 +230,7 @@ export class Graphics {
             fragmentShader: fragment
         });
     }
-    private static readonly mesh = new THREE.Mesh(this.planeGeometry, this.blipMaterial);
+    private static readonly mesh = new Mesh(this.planeGeometry, this.blipMaterial);
 
     static copyTexture(texture: Texture, blitMaterial?: ShaderMaterial) {
         const material = blitMaterial ?? this.blipMaterial;
@@ -292,12 +292,12 @@ export class Graphics {
 }
 
 /**@obsolete use Graphics.copyTexture */
-export function copyTexture(texture: THREE.Texture): THREE.Texture {
+export function copyTexture(texture: Texture): Texture {
     return Graphics.copyTexture(texture);
 }
 
 /**@obsolete use Graphics.textureToCanvas */
-export function textureToCanvas(texture: THREE.Texture, force: boolean = false): HTMLCanvasElement | null {
+export function textureToCanvas(texture: Texture, force: boolean = false): HTMLCanvasElement | null {
     return Graphics.textureToCanvas(texture, force);
 }
 

package/src/engine/extensions/NEEDLE_components.ts

@@ -6,6 +6,7 @@ import { builtinComponentKeyName } from "../engine_constants";
 import { resolveReferences } from "./extension_utils";
 import { apply } from "../../engine-components/js-extensions/Object3D";
 import { getLoader } from "../engine_gltf";
+import { Object3D } from "three";
 
 export const debug = debugExtension
 const componentsArrayExportKey = "$___Export_Components";
@@ -17,11 +18,11 @@ class ExtensionData {
 }
 
 class ExportData {
-    node: THREE.Object3D;
+    node: Object3D;
     nodeIndex: number;
     nodeDef: any;
 
-    constructor(node: THREE.Object3D, nodeIndex: number, nodeDef: any) {
+    constructor(node: Object3D, nodeIndex: number, nodeDef: any) {
         this.node = node;
         this.nodeIndex = nodeIndex;
         this.nodeDef = nodeDef;
@@ -78,7 +79,7 @@ export class NEEDLE_components implements GLTFLoaderPlugin {
     }
 
     // https://github.com/mrdoob/three.js/blob/efbfc67edc7f65cfcc61a389ffc5fd43ea702bc6/examples/jsm/exporters/GLTFExporter.js#L532
-    serializeUserData(node: THREE.Object3D, _nodeDef: any) {
+    serializeUserData(node: Object3D, _nodeDef: any) {
         const components = node.userData?.components;
         if (!components || components.length <= 0) return;
         // delete components before serializing user data to avoid circular references
@@ -86,7 +87,7 @@ export class NEEDLE_components implements GLTFLoaderPlugin {
         node[componentsArrayExportKey] = components;
     }
 
-    afterSerializeUserData(node: THREE.Object3D, _nodeDef) {
+    afterSerializeUserData(node: Object3D, _nodeDef) {
         if (node.type === "Scene") {
             if (debug)
                 console.log("DONE", JSON.stringify(_nodeDef));
@@ -102,7 +103,7 @@ export class NEEDLE_components implements GLTFLoaderPlugin {
         // console.log(_nodeDef, _nodeDef.mesh);
     }
 
-    writeNode(node: THREE.Object3D, nodeDef) {
+    writeNode(node: Object3D, nodeDef) {
         let nodeIndex = this.writer.json.nodes.length;
         console.log(node.name, nodeIndex, node.uuid);
         const context = new ExportData(node, nodeIndex, nodeDef);
@@ -198,7 +199,7 @@ export class NEEDLE_components implements GLTFLoaderPlugin {
         await Promise.all(loadComponents);
     }
 
-    private async createComponents(obj: THREE.Object3D, data: ExtensionData) {
+    private async createComponents(obj: Object3D, data: ExtensionData) {
         if (!data) return;
         const componentData = data[builtinComponentKeyName];
         if (componentData) {

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -43,11 +43,20 @@ export class NEEDLE_lighting_settings implements GLTFLoaderPlugin {
             if (ext) {
                 if (debug)
                     console.log("Apply \"" + this.name + "\", src: \"" + this.sourceId + "\"", ext);
-                // add a component to the root of the scene
-                const lightSettings = new Object3D();
-                lightSettings.name = "Needle LightSettings";
-                _result.scene.add(lightSettings);
-                const settings = GameObject.addNewComponent(lightSettings, SceneLightSettings, false);
+                let settings: SceneLightSettings | undefined = undefined;
+                // If the result scene has only one child we add the LightingSettingsComponent to that child
+                if (_result.scene.children.length === 1) {
+                    // add a component to the root of the scene
+                    settings = GameObject.addNewComponent(_result.scene.children[0], SceneLightSettings, false);
+                }
+                // if the scene already has multiple children we add it as a new object
+                else 
+                {
+                    const lightSettings = new Object3D();
+                    lightSettings.name = "Needle LightSettings";
+                    _result.scene.add(lightSettings);
+                    settings = GameObject.addNewComponent(lightSettings, SceneLightSettings, false);
+                }
                 settings.sourceId = this.sourceId;
                 settings.ambientIntensity = ext.ambientIntensity;
                 settings.ambientLight = new Color().fromArray(ext.ambientLight);
@@ -109,7 +118,7 @@ export class SceneLightSettings extends Behaviour {
         }
         if (this.ambientMode == AmbientMode.Flat) {
             if (this.ambientLight && !this._ambientLightObj) {
-                this._ambientLightObj = new AmbientLight(this.ambientLight, Math.PI * this.ambientIntensity);
+                this._ambientLightObj = new AmbientLight(this.ambientLight, this.ambientIntensity);
             }
             if (this._ambientLightObj) {
                 this.gameObject.add(this._ambientLightObj)

package/src/engine/extensions/NEEDLE_techniques_webgl.ts

@@ -1,7 +1,6 @@
 import { GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-import * as THREE from 'three';
 import { FindShaderTechniques, whiteDefaultTexture, ToUnityMatrixArray, SetUnitySphericalHarmonics } from '../engine_shaders';
-import { IUniform, RawShaderMaterial, Vector4 } from 'three';
+import { AlwaysDepth, BackSide, Camera, DoubleSide, EqualDepth, FrontSide, GreaterDepth, GreaterEqualDepth, IUniform, LessDepth, LessEqualDepth, LinearEncoding, Material, Matrix4, NotEqualDepth, Object3D, RawShaderMaterial, Vector3, Vector4 } from 'three';
 import { Context } from '../engine_setup';
 import { getParam } from "../engine_utils";
 import * as SHADERDATA from "../shaders/shaderData"
@@ -37,13 +36,13 @@ enum UniformType {
 }
 
 class ObjectRendererData {
-    objectToWorldMatrix: THREE.Matrix4 = new THREE.Matrix4();
-    worldToObjectMatrix: THREE.Matrix4 = new THREE.Matrix4();
+    objectToWorldMatrix: Matrix4 = new Matrix4();
+    worldToObjectMatrix: Matrix4 = new Matrix4();
 
     objectToWorld: Array<Vector4> = new Array<Vector4>();
     worldToObject: Array<Vector4> = new Array<Vector4>();
 
-    updateFrom(obj: THREE.Object3D) {
+    updateFrom(obj: Object3D) {
         this.objectToWorldMatrix.copy(obj.matrixWorld);
         ToUnityMatrixArray(this.objectToWorldMatrix, this.objectToWorld);
 
@@ -132,7 +131,7 @@ export class CustomShader extends RawShaderMaterial {
         this.uniforms["unity_SpecCube0"] = { value: envTexture };
         SetUnitySphericalHarmonics(this.uniforms, array);
         const hdr = Math.sqrt(Math.PI * .5);
-        this.uniforms["unity_SpecCube0_HDR"] = { value: new THREE.Vector4(hdr, hdr, hdr, hdr) };
+        this.uniforms["unity_SpecCube0_HDR"] = { value: new Vector4(hdr, hdr, hdr, hdr) };
         // this.needsUpdate = true;
         // this.uniformsNeedUpdate = true;
         if (debug) console.log("Set environment lighting", this.uniforms);
@@ -143,20 +142,20 @@ export class CustomShader extends RawShaderMaterial {
     private _objToWorldName = "hlslcc_mtx4x4unity_ObjectToWorld";
     private _worldToObjectName = "hlslcc_mtx4x4unity_WorldToObject";
 
-    private static viewProjection: THREE.Matrix4 = new THREE.Matrix4();
+    private static viewProjection: Matrix4 = new Matrix4();
     private static _viewProjectionValues: Array<Vector4> = [];
     private _viewProjectionName = "hlslcc_mtx4x4unity_MatrixVP";
 
-    private static viewMatrix: THREE.Matrix4 = new THREE.Matrix4();
+    private static viewMatrix: Matrix4 = new Matrix4();
     private static _viewMatrixValues: Array<Vector4> = [];
     private _viewMatrixName = "hlslcc_mtx4x4unity_MatrixV";
 
     private static _worldSpaceCameraPosName = "_WorldSpaceCameraPos";
-    private static _worldSpaceCameraPos: THREE.Vector3 = new THREE.Vector3();
+    private static _worldSpaceCameraPos: Vector3 = new Vector3();
 
-    private static _mainLightColor: THREE.Vector4 = new THREE.Vector4();
-    private static _mainLightPosition: THREE.Vector3 = new THREE.Vector3();
-    private static _lightData: THREE.Vector4 = new THREE.Vector4();
+    private static _mainLightColor: Vector4 = new Vector4();
+    private static _mainLightPosition: Vector3 = new Vector3();
+    private static _lightData: Vector4 = new Vector4();
 
     private _rendererData = new ObjectRendererData();
 
@@ -184,7 +183,7 @@ export class CustomShader extends RawShaderMaterial {
         this.onUpdateUniforms(camera, obj);
     }
 
-    onUpdateUniforms(camera?: THREE.Camera, obj?: any) {
+    onUpdateUniforms(camera?: Camera, obj?: any) {
 
         const context = Context.Current;
 
@@ -309,7 +308,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
         this.identifier = identifier;
     }
 
-    loadMaterial(index: number): Promise<THREE.Material> | null {
+    loadMaterial(index: number): Promise<Material> | null {
 
         const mat = this.parser.json.materials[index];
         if (!mat) {
@@ -328,7 +327,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
         const technique: SHADERDATA.Technique = shaders.techniques[techniqueIndex];
         if (!technique) return null;
 
-        return new Promise<THREE.Material>(async (resolve, reject) => {
+        return new Promise<Material>(async (resolve, reject) => {
             const bundle = await FindShaderTechniques(shaders, technique.program!);
             const frag = bundle?.fragmentShader;
             const vert = bundle?.vertexShader;
@@ -342,7 +341,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
             const techniqueUniforms = technique.uniforms;
 
             if (vert.includes("_Time"))
-                uniforms["_Time"] = { value: new THREE.Vector4(0, 0, 0, 0) };
+                uniforms["_Time"] = { value: new Vector4(0, 0, 0, 0) };
 
             for (const u in techniqueUniforms) {
                 const uniformName = u;
@@ -350,7 +349,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                 // const typeName = UniformType[uniformValues.type];
                 switch (uniformName) {
                     case "_TimeParameters":
-                        const timeUniform = new THREE.Vector4();
+                        const timeUniform = new Vector4();
                         uniforms[uniformName] = { value: timeUniform };
                         break;
 
@@ -422,7 +421,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                                 if (texIndex >= 0) {
                                     const tex = await this.parser.getDependency("texture", texIndex);
                                     if (tex) {
-                                        tex.encoding = THREE.LinearEncoding;
+                                        tex.encoding = LinearEncoding;
                                         tex.needsUpdate = true;
                                     }
                                     uniforms[key] = { value: tex };
@@ -436,7 +435,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                             }
                         }
                         if (Array.isArray(val) && val.length === 4) {
-                            uniforms[key] = { value: new THREE.Vector4(val[0], val[1], val[2], val[3]) };
+                            uniforms[key] = { value: new Vector4(val[0], val[1], val[2], val[3]) };
                             continue;
                         }
                         uniforms[key] = { value: val };
@@ -460,16 +459,16 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
             const culling = uniforms["_Cull"]?.value;
             switch (culling) {
                 case CullMode.Off:
-                    material.side = THREE.DoubleSide;
+                    material.side = DoubleSide;
                     break;
                 case CullMode.Front:
-                    material.side = THREE.BackSide;
+                    material.side = BackSide;
                     break;
                 case CullMode.Back:
-                    material.side = THREE.FrontSide;
+                    material.side = FrontSide;
                     break;
                 default:
-                    material.side = THREE.FrontSide;
+                    material.side = FrontSide;
                     break;
             }
 
@@ -477,31 +476,31 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
             switch (zTest) {
                 case ZTestMode.Equal:
                     material.depthTest = true;
-                    material.depthFunc = THREE.EqualDepth;
+                    material.depthFunc = EqualDepth;
                     break;
                 case ZTestMode.NotEqual:
                     material.depthTest = true;
-                    material.depthFunc = THREE.NotEqualDepth;
+                    material.depthFunc = NotEqualDepth;
                     break;
                 case ZTestMode.Less:
                     material.depthTest = true;
-                    material.depthFunc = THREE.LessDepth;
+                    material.depthFunc = LessDepth;
                     break;
                 case ZTestMode.LEqual:
                     material.depthTest = true;
-                    material.depthFunc = THREE.LessEqualDepth;
+                    material.depthFunc = LessEqualDepth;
                     break;
                 case ZTestMode.Greater:
                     material.depthTest = true;
-                    material.depthFunc = THREE.GreaterDepth;
+                    material.depthFunc = GreaterDepth;
                     break;
                 case ZTestMode.GEqual:
                     material.depthTest = true;
-                    material.depthFunc = THREE.GreaterEqualDepth;
+                    material.depthFunc = GreaterEqualDepth;
                     break;
                 case ZTestMode.Always:
                     material.depthTest = false;
-                    material.depthFunc = THREE.AlwaysDepth;
+                    material.depthFunc = AlwaysDepth;
                     break;
             }