@needle-tools/engine 3.0.1-alpha.4 → 3.1.0-alpha

package/src/engine/engine_license.ts

@@ -5,21 +5,12 @@ import { logoSVG } from "./assets";
 
 const debug = getParam("debuglicense");
 
+// This is modified by a bundler (e.g. vite)
+// Do not edit manually
+const HAS_LICENSE = false;
 
-// import licenseInformation from "./codegen/license.json";
-let licenseInformation: any = null;
-let licenseImportPromise: Promise<any> | null = null;
-try {
-    licenseImportPromise = import("./codegen/license.json");
-    licenseImportPromise.then(res => {
-        licenseInformation = res.default;
-        licenseImportPromise = null;
-        if (debug) console.log("License imported via dynamic import", licenseInformation)
-    }).catch(err => { if (debug) console.error("Error on dynamic license import", err) });
-}
-catch (err) {
-    if (debug)
-        console.log("Importing license failed", err)
+export function hasProLicense() {
+    return HAS_LICENSE;
 }
 
 
@@ -29,9 +20,7 @@ ContextRegistry.registerCallback(ContextEvent.ContextCreated, evt => {
 
 async function showLicenseInfo(ctx: IContext) {
     try {
-        // if(licenseImportPromise) await licenseImportPromise;
-        //@ts-ignore
-        if (!licenseInformation || licenseInformation.hasLicense !== true || debug) return onNonCommercialVersionDetected(ctx);
+        if (hasProLicense() !== true) return onNonCommercialVersionDetected(ctx);
     }
     catch (err) {
         if (debug) console.log("License check failed", err)

package/src/engine/engine_networking.ts

@@ -274,6 +274,10 @@ export class NetworkConnection implements INetworkConnection {
         return this._currentDelay;
     }
 
+    public sendPing() {
+        this.send("ping", { time: this.context.time.time });
+    }
+
     public userIsInRoom(id: string): boolean {
         return this._currentInRoom.indexOf(id) !== -1;
     }

package/src/engine/engine_serialization.ts

@@ -1,6 +1,7 @@
 import { serializeObject, deserializeObject } from "./engine_serialization_core";
-import * as builtin from "./engine_serialization_builtin_serializer";
-// export builtin so it will be called and registered
-export { serializeObject, deserializeObject, builtin };
 
-export { serializable, serializeable } from "./engine_serialization_decorator"
+export { serializeObject, deserializeObject };
+
+export { serializable, serializeable } from "./engine_serialization_decorator"
+
+export * from "./engine_serialization_builtin_serializer";

package/src/engine/engine_serialization_builtin_serializer.ts

@@ -7,6 +7,7 @@ import { CallInfo, EventList } from "../engine-components/EventList";
 import { Color, Object3D, Texture, WebGLRenderTarget } from "three";
 import { RenderTexture } from "./engine_texture";
 import { isDevEnvironment } from "../engine/debug/debug";
+import { resolveUrl } from "./engine_utils";
 
 // export class SourcePath {
 //     src?:string
@@ -300,8 +301,8 @@ class EventListSerializer extends TypeSerializer {
         return undefined;
     }
 
-    private createEventMethod(target : object, methodName: string, args?: any) : Function | undefined {
-        
+    private createEventMethod(target: object, methodName: string, args?: any): Function | undefined {
+
         return (...forwardedArgs) => {
             const method = target[methodName];
             if (typeof method === "function") {
@@ -339,4 +340,23 @@ export class RenderTextureSerializer extends TypeSerializer {
         return undefined;
     }
 }
-new RenderTextureSerializer();
+new RenderTextureSerializer();
+
+
+export class UriSerializer extends TypeSerializer {
+    constructor() {
+        super([URL]);
+    }
+
+    onSerialize(_data: string, _context: SerializationContext) {
+        return null;
+    }
+
+    onDeserialize(data: string, _context: SerializationContext) {
+        if (typeof data === "string") {
+            return resolveUrl(_context.gltfId, data);
+        }
+        return undefined;
+    }
+}
+new UriSerializer();

package/src/engine/engine_serialization_core.ts

@@ -173,6 +173,7 @@ export class SerializationContext {
     root: THREE.Object3D;
 
     gltf?: GLTF;
+    /** the url of the glb that is currently being loaded */
     gltfId?: SourceIdentifier;
     object!: THREE.Object3D;
     target?: object;
@@ -290,16 +291,21 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
                 context.type = undefined;
                 context.path = key;
 
+                if (obj.onBeforeDeserializeMember !== undefined) {
+                    // callback to the instance, if it returns true assume it's done all the things itself
+                    if (obj.onBeforeDeserializeMember(key, data, context) === true) continue;
+                }
+
                 if (serializedEntryInfo === null) {
                     obj[key] = data;
+                    // if(typeof data === "string"){
+                    //     const serializer = helper.getSerializerForConstructor(String);
+                    //     const res = serializer?.onDeserialize(data, context);
+                    //     if(res !== undefined) obj[key] = res;
+                    // }
                 }
                 else {
 
-                    if (obj.onBeforeDeserializeMember !== undefined) {
-                        // callback to the instance, if it returns true assume it's done all the things itself
-                        if (obj.onBeforeDeserializeMember(key, data, context) === true) continue;
-                    }
-
                     if (Array.isArray(serializedEntryInfo)) {
                         for (let i = 0; i < serializedEntryInfo.length; i++) {
                             const typeInfoOrConstructor = serializedEntryInfo[i];
@@ -314,24 +320,25 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
                         obj[key] = tryResolve(serializedEntryInfo);
                     }
 
-                    function tryResolve(typeInfoOrConstructor) {
-                        const typeInformationOrConstructor = typeInfoOrConstructor as ITypeInformation;
-                        // if the entry does specify an object of type ITypeInformation and has the type field set
-                        const type = typeInformationOrConstructor.type;
-                        if (type) {
-                            return deserializeObjectWithType(data, type, context, undefined, obj[key]);
-                        }
-                        // it can also just contain a constructor
-                        else {
-                            const constructor = typeInfoOrConstructor as Constructor<any>;
-                            return deserializeObjectWithType(data, constructor, context, undefined, obj[key]);
-                        }
-                    }
 
                     buffer.length = 0;
+                }
+
+                if (obj.onAfterDeserializeMember !== undefined) {
+                    obj.onAfterDeserializeMember(key, data, context);
+                }
 
-                    if (obj.onAfterDeserializeMember !== undefined) {
-                        obj.onAfterDeserializeMember(key, data, context);
+                function tryResolve(typeInfoOrConstructor) {
+                    const typeInformationOrConstructor = typeInfoOrConstructor as ITypeInformation;
+                    // if the entry does specify an object of type ITypeInformation and has the type field set
+                    const type = typeInformationOrConstructor.type;
+                    if (type) {
+                        return deserializeObjectWithType(data, type, context, undefined, obj[key]);
+                    }
+                    // it can also just contain a constructor
+                    else {
+                        const constructor = typeInfoOrConstructor as Constructor<any>;
+                        return deserializeObjectWithType(data, constructor, context, undefined, obj[key]);
                     }
                 }
             }

package/src/engine/engine_utils.ts

@@ -203,30 +203,51 @@ export function delay(milliseconds: number): Promise<void> {
     });
 }
 
-// if a timeline is exported via menu item the audio clip path is relative to the glb (same folder)
+// 1) if a timeline is exported via menu item the audio clip path is relative to the glb (same folder)
 // we need to detect that here and build the new audio source path relative to the new glb location
 // the same is/might be true for any file that is/will be exported via menu item
-const debugGetPath = getParam("debugsourcepath");
-export function getPath(source: SourceIdentifier | undefined, uri: string): string {
-    if (source === undefined) {
-        if (debugGetPath) console.warn("getPath: source is undefined, returning uri", uri);
+// 2) if the needle.config assetDirectory is modified (from e.g. /assets to /needle/assets) when building a distributable our vite transform and copy plugin will move the files to dist/assets hence we cannot use project-relative paths (because the path changes). What we do instead if make all paths serialized in a glb relative to the glb. The rel: prefix is used to detect urls that need to be resolved.
+const debugGetPath = getParam("debugresolveurl");
+
+export const relativePathPrefix = "rel:";
+
+/** @deprecated use resolveUrl instead */
+export function getPath(source:SourceIdentifier|undefined, uri:string) : string {
+    return resolveUrl(source, uri);
+}
+/**
+ * Use to resolve a url serialized in a glTF file
+ * @param source The uri of the loading file
+ * @param uri The uri of the file to resolve, can be absolute or relative
+ * @returns The resolved uri
+ */
+export function resolveUrl(source: SourceIdentifier | undefined, uri: string): string {
+    if (uri === undefined) {
+        if (debugGetPath) console.warn("getPath: uri is undefined, returning uri", uri);
+        return uri;
+    }
+    if(uri.startsWith("./")) {
         return uri;
     }
     if (uri.startsWith("http")) {
         if (debugGetPath) console.warn("getPath: uri is absolute, returning uri", uri);
         return uri;
     }
+    if (source === undefined) {
+        if (debugGetPath) console.warn("getPath: source is undefined, returning uri", uri);
+        return uri;
+    }
+    if(uri.startsWith(relativePathPrefix)){
+        uri = uri.substring(4);
+    }
     const pathIndex = source.lastIndexOf("/");
     if (pathIndex >= 0) {
-        let newUri = source.substring(0, pathIndex + 1);
-
-        const uriDirectoryIndex = uri.lastIndexOf("/");
-        if (uriDirectoryIndex >= 0) {
-            newUri += uri.substring(uriDirectoryIndex + 1);
-        } else {
-            newUri += uri;
-        }
-        if (debugGetPath) console.log("getPath:", source, " - changed uri from\n", uri, "\n→ ", newUri);
+        // Take the source uri as the base path
+        const basePath = source.substring(0, pathIndex + 1);
+        // Append the relative uri
+        let newUri = basePath + uri;
+        // newUri = new URL(newUri, globalThis.location.href).href;
+        if (debugGetPath) console.log("source:", source, "- changed uri \nfrom", uri, "\n→ ", newUri, "\n" + basePath);
         return newUri;
     }
     return uri;

package/src/engine/extensions/NEEDLE_animator_controller_model.ts

@@ -32,6 +32,7 @@ export declare type StateMachine = {
 export declare type State = {
     name: string,
     hash: number;
+    speed?: number;
     motion: Motion,
     transitions: Transition[],
     behaviours: StateMachineBehaviourModel[],

package/src/engine/extensions/NEEDLE_progressive.ts

@@ -3,7 +3,7 @@ import { GLTF, GLTFLoader, GLTFLoaderPlugin, GLTFParser } from "three/examples/j
 import { SourceIdentifier } from "../engine_types";
 import { Context } from "../engine_setup";
 import { addDracoAndKTX2Loaders } from "../engine_loaders";
-import { delay, getParam, getPath } from "../engine_utils";
+import { delay, getParam, resolveUrl } from "../engine_utils";
 
 export const EXTENSION_NAME = "NEEDLE_progressive";
 
@@ -130,7 +130,7 @@ export class NEEDLE_progressive implements GLTFLoaderPlugin {
         if (progressiveInfo) {
             if (debug)
                 console.log(key, progressiveInfo.uri, progressiveInfo.guid);
-            const uri = getPath(source, progressiveInfo.uri);
+            const uri = resolveUrl(source, progressiveInfo.uri);
             if (uri.endsWith(".glb") || uri.endsWith(".gltf")) {
                 if (!progressiveInfo.guid) {
                     console.warn("missing pointer for glb/gltf texture", progressiveInfo);

package/src/engine-components/AnimatorController.ts

@@ -249,9 +249,16 @@ export class AnimatorController {
 
             if (action) {
                 const dur = state.motion.clip!.duration;
-                const normalizedTime = dur <= 0 ? 1 : action.time / dur;
-                const makeTransition = transition.hasExitTime ? normalizedTime >= transition.exitTime : true;
-                // console.log(state.name, makeTransition, transition.hasExitTime, normalizedTime, transition.exitTime)
+                const normalizedTime = dur <= 0 ? 1 : Math.abs(action.time / dur);
+                let makeTransition = false;
+                if (transition.hasExitTime) {
+                    if (action.timeScale > 0) makeTransition = normalizedTime >= transition.exitTime;
+                    // When the animation is playing backwards we need to check exit time inverted
+                    else if(action.timeScale < 0) makeTransition = 1 - normalizedTime >= transition.exitTime;
+                }
+                else {
+                    makeTransition = true;
+                }
                 if (makeTransition) {
                     // if (transition.hasExitTime && transition.exitTime >= .9999) 
                     action.clampWhenFinished = true;
@@ -283,6 +290,12 @@ export class AnimatorController {
                 action.time = 0;
                 action.play();
             }
+            else if (action.time <= 0 && action.timeScale < 0) {
+                didTriggerLooping = true;
+                action.reset();
+                action.time = action.getClip().duration;
+                action.play();
+            }
         }
 
         // call update state behaviours:
@@ -367,9 +380,11 @@ export class AnimatorController {
                 action.stop();
             action.reset();
             action.timeScale = this._speed;
+            if (state.speed !== undefined) action.timeScale *= state.speed;
             action.enabled = true;
             const duration = state.motion.clip!.duration;
             action.time = offsetNormalized * duration;
+            if(action.timeScale < 0) action.time = duration - action.time;
             action.clampWhenFinished = true;
             action.setLoop(LoopOnce, 0);
             if (durationInSec > 0)

package/src/engine-components/AudioSource.ts

@@ -82,7 +82,7 @@ export class AudioSource extends Behaviour {
         document.addEventListener('touchstart', fn);
     }
 
-    @serializable()
+    @serializable(URL)
     clip: string = "";
 
     @serializable()
@@ -168,48 +168,11 @@ export class AudioSource extends Behaviour {
     public get ShouldPlay(): boolean { return this.shouldPlay; }
 
 
-    private _focusCallback: any;
-    private _muteChangedCallback: any;
-
     awake() {
         this.audioLoader = new THREE.AudioLoader();
         if (this.playOnAwake) this.shouldPlay = true;
-
-        window.addEventListener('visibilitychange', _evt => {
-            switch (document.visibilityState) {
-                case "hidden":
-                    this.wasPlaying = this.isPlaying;
-                    this.pause();
-                    break;
-                case "visible":
-                    if (this.wasPlaying) this.play();
-                    break;
-            }
-        });
-
-        this._focusCallback = () => {
-            if (this.enabled && this.playOnAwake && !this.isPlaying && AudioSource._userInteractionRegistered) {
-                this.play();
-            }
-        }
-
-        this._muteChangedCallback = () => {
-            if (this.context.application.muted)
-                this.sound?.setVolume(0);
-            else
-                this.sound?.setVolume(this.volume);
-        }
-
-        this.context.application.addEventListener(ApplicationEvents.Visible, this._focusCallback);
-        this.context.application.addEventListener(ApplicationEvents.MuteChanged, this._muteChangedCallback);
     }
 
-    onDestroy() {
-        this.context.application.removeEventListener(ApplicationEvents.Visible, this._focusCallback);
-        this.context.application.removeEventListener(ApplicationEvents.MuteChanged, this._muteChangedCallback);
-    }
-
-
     onEnable(): void {
         if (!AudioSource._userInteractionRegistered) {
             AudioSource._beginWaitForUserInteraction(() => {
@@ -220,12 +183,40 @@ export class AudioSource extends Behaviour {
         else if (this.playOnAwake && this.context.application.isVisible) {
             this.play();
         }
+        globalThis.addEventListener('visibilitychange', this.onVisibilityChanged);
+        this.context.application.addEventListener(ApplicationEvents.MuteChanged, this.onApplicationMuteChanged);
     }
 
     onDisable() {
+        globalThis.removeEventListener('visibilitychange', this.onVisibilityChanged);
+        this.context.application.removeEventListener(ApplicationEvents.MuteChanged, this.onApplicationMuteChanged);
         this.stop();
     }
 
+    private onVisibilityChanged = () => {
+        switch (document.visibilityState) {
+            case "hidden":
+                this.wasPlaying = this.isPlaying;
+                if (this.isPlaying) {
+                    this.pause();
+                }
+                break;
+            case "visible":
+                if (debug) console.log("visible", this.enabled, this.playOnAwake, !this.isPlaying, AudioSource._userInteractionRegistered, this.wasPlaying);
+                if (this.enabled && this.playOnAwake && !this.isPlaying && AudioSource._userInteractionRegistered && this.wasPlaying) {
+                    this.play();
+                }
+                break;
+        }
+    }
+
+    private onApplicationMuteChanged = () => {
+        if (this.context.application.muted)
+            this.sound?.setVolume(0);
+        else
+            this.sound?.setVolume(this.volume);
+    }
+
     private lerp = (x, y, a) => x * (1 - a) + y * a;
 
     private onLoaded(buffer) {

package/src/engine-components/CameraUtils.ts

@@ -6,7 +6,7 @@ import { RGBAColor } from "./js-extensions/RGBAColor";
 import { ContextEvent, ContextRegistry } from "../engine/engine_context_registry";
 import { getCameraController } from "../engine/engine_camera";
 import { Camera } from "./Camera";
-import { EngineElement } from "../engine/engine_element";
+import { NeedleEngineHTMLElement } from "../engine/engine_element";
 
 ContextRegistry.registerCallback(ContextEvent.MissingCamera, (evt) => {
     const scene = evt.context.scene;
@@ -31,7 +31,7 @@ ContextRegistry.registerCallback(ContextEvent.ContextCreated, (evt) => {
     if (!evt.context.mainCamera) return;
 
     // check if the <needle-engine controls> is not set to false
-    const engineElement = evt.context.domElement as EngineElement
+    const engineElement = evt.context.domElement as NeedleEngineHTMLElement
 
     if (engineElement?.cameraControls === true) {
 

package/src/engine-components/Component.ts

@@ -9,6 +9,7 @@ import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instan
 import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision, ICollider } from "../engine/engine_types";
 import { addNewComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components";
 import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject";
+import { resolveUrl } from "../engine/engine_utils";
 
 
 // export interface ISerializationCallbackReceiver {
@@ -641,7 +642,6 @@ class Component implements IComponent, EventTarget {
 
         return false;
     }
-
 }
 
 class Behaviour extends Component {

package/src/engine-components/ParticleSystem.ts

@@ -52,6 +52,7 @@ export class ParticleSystemRenderer extends Behaviour {
     @serializable()
     minParticleSize!: number;
 
+
     start() {
         if (this.maxParticleSize !== .5 && this.minParticleSize !== 0) {
             if (isDevEnvironment()) {
@@ -192,6 +193,7 @@ class ParticleSystemEmissionOverTime extends BaseValueGenerator {
     }
 
     genValue(): number {
+        if (!this.system.isPlaying) return 0;
         if (!this.system.emission.enabled) return 0;
         if (this.system.currentParticles >= this.system.maxParticles) return 0;
         // emission over time
@@ -219,6 +221,7 @@ class ParticleSystemEmissionOverTime extends BaseValueGenerator {
 class ParticleSystemEmissionOverDistance extends BaseValueGenerator {
 
     genValue(): number {
+        if (!this.system.isPlaying) return 0;
         // this seems not be called yet
         return 0;
         // if (this.system.currentParticles >= this.system.maxParticles) return 0;
@@ -250,14 +253,19 @@ abstract class ParticleSystemBaseBehaviour implements Behavior {
     clone(): Behavior { throw new Error("Method not implemented."); }
 }
 
+const $startFrame = Symbol("startFrame")
 class TextureSheetAnimationBehaviour extends ParticleSystemBaseBehaviour {
     type: string = "NeedleTextureSheet"
 
+    // initialize(_particle: Particle): void {
+    //     _particle[$startFrame] = this.system.textureSheetAnimation.getStartIndex();
+    // }
+
     update(particle: Particle, _delta: number) {
         const sheet = this.system.textureSheetAnimation;
         if (sheet.enabled) {
             const t01 = particle.age / particle.life;
-            const index = sheet.evaluate(t01);;
+            const index = sheet.evaluate(t01);
             if (index !== undefined)
                 particle.uvTile = index;
         }
@@ -325,8 +333,9 @@ class SizeBehaviour extends ParticleSystemBaseBehaviour {
                 size *= this.system.sizeOverLifetime.evaluate(age01, undefined, particle[$sizeLerpFactor]).x;
             const scaleFactor = this.system.worldScale.x / this.system.cameraScale;
             particle.size = particle.startSize * size * scaleFactor;
-            // in Unity this is viewport size
-            particle.size = Mathf.clamp(particle.size, this._minSize, this._maxSize);
+            // in Unity this is viewport size, we don't really support this yet (and the renderer is logging a warning)
+            // so for now it's disabled again
+            // particle.size = Mathf.clamp(particle.size, this._minSize, this._maxSize);
         }
     }
 }
@@ -378,6 +387,7 @@ class TrailBehaviour extends ParticleSystemBaseBehaviour {
 
 const $startVelocity = Symbol("startVelocity");
 const $gravityFactor = Symbol("gravityModifier");
+const $gravitySpeed = Symbol("gravitySpeed");
 const $velocityLerpFactor = Symbol("velocity lerp factor");
 const temp3 = new Vector3();
 const temp4 = new Quaternion();
@@ -401,6 +411,7 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
 
         const gravityFactor = this.system.main.gravityModifier.evaluate(Math.random(), Math.random()) / (9.81 * 2);
         particle[$gravityFactor] = gravityFactor * simulationSpeed;
+        particle[$gravitySpeed] = 1;
 
         particle[$velocityLerpFactor] = Math.random();
 
@@ -417,7 +428,8 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
         let gravityFactor = particle[$gravityFactor];
         if (gravityFactor !== 0) {
             // gravityFactor *= -1;
-            temp3.copy(this._gravityDirection).multiplyScalar(gravityFactor);
+            temp3.copy(this._gravityDirection).multiplyScalar(gravityFactor * particle[$gravitySpeed]);
+            particle[$gravitySpeed] += delta;
             if (debug) Gizmos.DrawDirection(particle.position, temp3, 0x0000ff, 0, false, 10);
             baseVelocity.add(temp3);
         }
@@ -537,7 +549,7 @@ class ParticleSystemInterface implements ParticleSystemParameters {
         }
         switch (this.system.renderer.renderMode) {
             case ParticleSystemRenderMode.Billboard: return RenderMode.BillBoard;
-            // case ParticleSystemRenderMode.Stretch: return RenderMode.Stretch;
+            case ParticleSystemRenderMode.Stretch: return RenderMode.StretchedBillBoard;
             case ParticleSystemRenderMode.HorizontalBillboard: return RenderMode.LocalSpace;
             case ParticleSystemRenderMode.VerticalBillboard: return RenderMode.LocalSpace;
             case ParticleSystemRenderMode.Mesh: return RenderMode.LocalSpace;
@@ -587,8 +599,8 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
                 }
             }, true)
         }
+
         this._isPlaying = true;
-        this._time = 0;
 
         // https://github.com/Alchemist0823/three.quarks/pull/35
         if (this._particleSystem) {
@@ -598,12 +610,40 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
         this.emission?.reset();
     }
 
-    pause() {
+    pause(includeChildren = true) {
+        if (includeChildren) {
+            GameObject.foreachComponent(this.gameObject, comp => {
+                if (comp instanceof ParticleSystem && comp !== this) {
+                    comp.pause(false);
+                }
+            }, true)
+        }
         this._isPlaying = false;
     }
-    stop() {
+
+    /** clear=true removes all emitted particles */
+    stop(includeChildren = true, clear: boolean = false) {
+        if (includeChildren) {
+            GameObject.foreachComponent(this.gameObject, comp => {
+                if (comp instanceof ParticleSystem && comp !== this) {
+                    comp.stop(false, clear);
+                }
+            }, true)
+        }
         this._isPlaying = false;
         this._time = 0;
+        if (clear) this.reset();
+    }
+
+    /** remove emitted particles and reset time */
+    reset() {
+        this._time = 0;
+        if (this._particleSystem) {
+            this._particleSystem.particleNum = 0;
+            this._particleSystem["emissionState"].time = 0;
+            this._particleSystem["emitEnded"] = false;
+            this.emission?.reset();
+        }
     }
 
     private _state?: ParticlesEmissionState;
@@ -872,8 +912,10 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
             console.log(`Particles ${this.name} - Prewarm for ${framesToSimulate} frames (${timeToSimulate} sec). Duration: ${duration}, Lifetime: ${lifetime}`);
         for (let i = 0; i < framesToSimulate; i++) {
             if (this.currentParticles >= this.maxParticles) break;
-            if (Date.now() - startTime > 2) {
-                console.warn(`Particles ${this.name} - Prewarm took too long. Aborting.`);
+            const timePassed = Date.now() - startTime;
+            if (timePassed > 2000) {
+                console.warn(`Particles ${this.name} - Prewarm took too long. Aborting: ${timePassed}`);
+                break;
             }
             this.onUpdate();
             this.onSimulate(dt);