@needle-tools/engine 3.5.4-alpha → 3.5.5-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.5.4-alpha",
+    "version": "3.5.5-alpha",
     "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/copyfiles.js

@@ -1,5 +1,5 @@
 
-import { resolve, join } from 'path'
+import { resolve, join, isAbsolute } from 'path'
 import { existsSync, statSync, mkdirSync, readdirSync, copyFileSync, mkdir } from 'fs';
 import { builtAssetsDirectory, tryLoadProjectConfig } from './config.js';
 
@@ -51,6 +51,30 @@ async function run(isBuild, config) {
         if (!existsSync(outDir)) {
             mkdirSync(outDir);
         }
+
+        // copy a list of files or directories declared in build.copy = [] in the needle.config.json
+        /*
+        "build": {
+            "copy": ["myFolder", "myFile.txt"]
+        }
+        */
+        if (needleConfig?.build?.copy) {
+            const arr = needleConfig.build.copy;
+            for (let i = 0; i < arr.length; i++) {
+                const entry = arr[i];
+                if (Array.isArray(entry)) {
+                    console.log("WARN: build.copy can only contain string paths to copy to. Found array instead.");
+                    continue;
+                }
+                const src = resolve(baseDir, entry);
+                const dest = resolvePath(outDir, entry);
+                if (existsSync(src)) {
+                    console.log(`[${pluginName}] - Copy ${entry} to ${outdirName}/${entry}`)
+                    copyRecursiveSync(src, dest);
+                }
+            }
+        }
+
         // copy assets dir
         const assetsDir = resolve(baseDir, assetsDirName);
         if (existsSync(assetsDir)) {
@@ -68,13 +92,36 @@ async function run(isBuild, config) {
     }
 }
 
+/** resolves relative or absolute paths to a path inside the out directory
+ * for example D:/myFile.txt would resolve to outDir/myFile.txt
+ * wherereas "some/relative/path" would become outDir/some/relative/path
+ */
+function resolvePath(outDir, pathValue) {
+    if (isAbsolute(pathValue)) {
+        var exists = existsSync(pathValue);
+        if (!exists) return null;
+        var stats = exists && statSync(pathValue);
+        if (stats.isDirectory()) {
+            const dirName = pathValue.replaceAll('\\', '/').split('/').pop();
+            return resolve(outDir, dirName);
+        }
+        const fileName = pathValue.replaceAll('\\', '/').split('/').pop();
+        return resolve(outDir, fileName);
+    }
+    return resolve(outDir, pathValue);
+}
+
 function copyRecursiveSync(src, dest) {
+    if (dest === null) {
+        console.log(`[${pluginName}] - Copy ${src} to ${dest} - dest is null`)
+        return;
+    }
     var exists = existsSync(src);
     var stats = exists && statSync(src);
     var isDirectory = exists && stats.isDirectory();
     if (isDirectory) {
         if (!existsSync(dest))
-            mkdirSync(dest);
+            mkdirSync(dest, { recursive: true });
         readdirSync(src).forEach(function (childItemName) {
             copyRecursiveSync(join(src, childItemName), join(dest, childItemName));
         });

package/plugins/vite/license.js

@@ -1,5 +1,6 @@
 import { loadConfig } from './config.js';
 
+let didLog = false;
 
 export const needleLicense = (command, config, userSettings) => {
 
@@ -7,15 +8,27 @@ export const needleLicense = (command, config, userSettings) => {
         name: "needle-license",
         enforce: 'pre',
         async transform(src, id) {
-            const isNeedleEngineFile = id.includes("engine/engine_license") || id.includes("needle-tools_engine.js");
+            const isNeedleEngineFile = id.includes("engine/engine_license") || id.includes("needle-tools_engine");
             // sometimes the actual license parameter is in a unnamed chunk file
             const isViteChunkFile = id.includes("chunk") && id.includes(".vite");
             if (isNeedleEngineFile || isViteChunkFile) {
                 const needleConfig = await loadConfig();
                 if (needleConfig) {
                     if (typeof needleConfig.license === "string") {
-                        src = src.replace("const NEEDLE_ENGINE_LICENSE_TYPE: string = \"\";", "const NEEDLE_ENGINE_LICENSE_TYPE: string = \"" + needleConfig.license + "\";");
-                        return { code: src, map: null }
+                        if (!didLog) {
+                            didLog = true;
+                            console.log("Applying license: " + needleConfig.license);
+                        }
+                        const index = src.indexOf("NEEDLE_ENGINE_LICENSE_TYPE");
+                        if (index >= 0) {
+                            const end = src.indexOf(";", index);
+                            if (end >= 0) {
+                                const line = src.substring(index, end);
+                                const replaced = "NEEDLE_ENGINE_LICENSE_TYPE = \"" + needleConfig.license + "\"";
+                                src = src.replace(line, replaced);
+                                return { code: src, map: null }
+                            }
+                        }
                     }
                 }
                 else {

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 { ActionBuilder } from "../../engine-components/export/usdz/extensions/behavior/BehavioursBuilder";
@@ -215,7 +215,7 @@ import { XRGrabModel } from "../../engine-components/webxr/WebXRGrabRendering";
 import { XRGrabRendering } from "../../engine-components/webxr/WebXRGrabRendering";
 import { XRRig } from "../../engine-components/webxr/WebXRRig";
 import { XRState } from "../../engine-components/XRFlag";
-
+
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("ActionBuilder", ActionBuilder);

package/src/engine/engine_license.ts

@@ -7,7 +7,7 @@ const debug = getParam("debuglicense");
 
 // This is modified by a bundler (e.g. vite)
 // Do not edit manually
-const NEEDLE_ENGINE_LICENSE_TYPE: string = "";
+const NEEDLE_ENGINE_LICENSE_TYPE: string = "basic";
 if (debug) console.log("License Type: " + NEEDLE_ENGINE_LICENSE_TYPE)
 
 export function hasProLicense() {

package/src/engine/engine_three_utils.ts

@@ -50,13 +50,13 @@ export function setWorldPositionXYZ(obj: Object3D, x: number, y: number, z: numb
 }
 
 
+const _worldQuaternions = new CircularBuffer(() => new Quaternion(), 100);
 const _worldQuaternionBuffer: Quaternion = new Quaternion();
-const _worldQuaternion: Quaternion = new Quaternion();
 const _tempQuaternionBuffer2: Quaternion = new 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) return _worldQuaternions.get().identity();
+    const quat = target ?? _worldQuaternions.get();
     if (!obj.parent) return quat.copy(obj.quaternion);
     obj.getWorldQuaternion(quat);
     return quat;
@@ -79,14 +79,16 @@ export function setWorldQuaternionXYZW(obj: Object3D, x: number, y: number, z: n
     setWorldQuaternion(obj, _worldQuaternionBuffer);
 }
 
+const _worldScaleBuffer = new CircularBuffer(() => new Vector3(), 100);
 const _worldScale: Vector3 = new Vector3();
-const _worldScale2: Vector3 = new 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;
+    if (!vec)
+        vec = _worldScaleBuffer.get();
+    if (!obj) return vec.set(0, 0, 0);
+    if (!obj.parent) return vec.copy(obj.scale);
+    obj.getWorldScale(vec);
+    return vec;
 }
 
 export function setWorldScale(obj: Object3D, vec: Vector3) {
@@ -95,7 +97,7 @@ export function setWorldScale(obj: Object3D, vec: Vector3) {
         obj.scale.copy(vec);
         return;
     }
-    const tempVec = _worldScale2;
+    const tempVec = _worldScale;
     const obj2 = obj.parent;
     obj2.getWorldScale(tempVec);
     obj.scale.copy(vec);
@@ -109,6 +111,18 @@ export function forward(obj: Object3D): Vector3 {
     return _forward.set(0, 0, 1).applyQuaternion(_forwardQuat);
 }
 
+const _worldDirectionBuffer = new CircularBuffer(() => new Vector3(), 100);
+const _worldDirectionQuat = new Quaternion();
+/** Get the world direction. Returns world forward if nothing is passed in.
+ * Pass in a relative direction to get it converted to world space (e.g. dir = new Vector3(0, 1, 1))
+ * The returned vector will not be normalized
+ */
+export function getWorldDirection(obj: Object3D, dir?: Vector3) {
+    // If no direction is passed in set the direction to the forward vector
+    if (!dir) dir = _worldDirectionBuffer.get().set(0, 0, 1);
+    getWorldQuaternion(obj, _worldDirectionQuat);
+    return dir.applyQuaternion(_worldDirectionQuat);
+}
 
 
 const _worldEulerBuffer: Euler = new Euler();
@@ -119,14 +133,16 @@ const _worldRotation: Vector3 = new Vector3();
 
 // world euler (in radians)
 export function getWorldEuler(obj: Object3D): Euler {
-    obj.getWorldQuaternion(_worldQuaternion);
-    _worldEuler.setFromQuaternion(_worldQuaternion);
+    const quat = _worldQuaternions.get();
+    obj.getWorldQuaternion(quat);
+    _worldEuler.setFromQuaternion(quat);
     return _worldEuler;
 }
 
 // world euler (in radians)
 export function setWorldEuler(obj: Object3D, val: Euler) {
-    setWorldQuaternion(obj, _worldQuaternion.setFromEuler(val));;
+    const quat = _worldQuaternions.get();
+    setWorldQuaternion(obj, quat.setFromEuler(val));;
 }
 
 // returns rotation in degrees

package/src/engine/engine_utils.ts

@@ -408,4 +408,38 @@ export function isSafari() {
 
 export function isQuest() {
     return navigator.userAgent.includes("OculusBrowser");
+}
+
+
+
+const cloudflareIPRegex = /ip=(?<ip>.+?)\n/s;
+export async function getIpCloudflare() {
+    const data = await fetch('https://www.cloudflare.com/cdn-cgi/trace');
+    const body = await data.text();
+    // we are only interested in the ip= part:
+    const match = cloudflareIPRegex.exec(body);
+    if (match)
+        return match[1];
+    return null;
+}
+
+export async function getIp() {
+    const res = await fetch("https://api.db-ip.com/v2/free/self");
+    const json = await res.json();
+    return json.ipAddress;
+}
+
+export type IpAndLocation = {
+    ipAddress: string;
+    continentCode: string;
+    continentName: string;
+    countryCode: string;
+    countryName: string;
+    stateProv: string;
+    city: string;
+}
+export async function getIpAndLocation(): Promise<IpAndLocation> {
+    const res = (await fetch("https://api.db-ip.com/v2/free/self").catch(() => null))!;
+    const json = await res.json() as IpAndLocation;
+    return json;
 }

package/src/engine-components/AnimatorController.ts

@@ -408,7 +408,7 @@ export class AnimatorController {
                 }
             }
         }
-        else if (isDevEnvironment()) {
+        else if (debug) {
             if (!state["__warned_no_motion"]) {
                 state["__warned_no_motion"] = true;
                 console.warn("No action", state.motion, this);