@needle-tools/engine 2.53.0-pre → 2.54.2-pre

package/src/engine/engine_element_loading.ts

@@ -4,6 +4,7 @@ import { LoadingProgressArgs } from "./engine_setup";
 import { getParam } from "./engine_utils";
 
 const debug = getParam("debugloadingbar");
+const debugRendering = getParam("debugloadingbarrendering");
 
 export class LoadingElementOptions {
     className?: string;
@@ -43,12 +44,14 @@ export function calculateProgress01(progress: LoadingProgressArgs) {
 
 export class EngineLoadingView implements ILoadingViewHandler {
 
+    static LoadingContainerClassName = "loading";
+
     // the raw progress
     loadingProgress: number = 0;
 
     private container: HTMLElement;
     private _progress: number = 0;
-    private _allowCustomLoadingElement: boolean = false;
+    private _allowCustomLoadingElement: boolean = true;
     private _loadingElement?: HTMLElement;
     private _loadingTextContainer: HTMLElement | null = null;
     private _loadingBar: HTMLElement | null = null;
@@ -61,20 +64,21 @@ export class EngineLoadingView implements ILoadingViewHandler {
     }
 
     onLoadingBegin(message?: string) {
+        if(debug) console.log("Begin Loading")
         if (!this._loadingElement) {
             for (let i = 0; i < this.container.children.length; i++) {
                 const el = this.container.children[i] as HTMLElement;
-                if (el.classList.contains("loading")) {
+                if (el.classList.contains(EngineLoadingView.LoadingContainerClassName)) {
                     if (!this._allowCustomLoadingElement) {
-                        console.warn("Custom loading container is not allowed")
+                        if(debug) console.warn("Remove custom loading container")
                         this.container.removeChild(el);
                         continue;
                     }
                     this._loadingElement = this.createLoadingElement(el);
-                    return;
                 }
             }
-            this._loadingElement = this.createLoadingElement();
+            if (!this._loadingElement)
+                this._loadingElement = this.createLoadingElement();
         }
         this._progress = 0;
         this.loadingProgress = 0;
@@ -121,9 +125,11 @@ export class EngineLoadingView implements ILoadingViewHandler {
         if (this._progressLoop) return;
         let dt = 1 / 12;
         const max = 1 - .05;
+        if(debugRendering) dt = 1 / 500;
         this._progressLoop = setInterval(() => {
             if (this.loadingProgress >= 1 && this._progress >= max) {
                 if (this._loadingElement) {
+                    if(debug) console.log("Hiding loading element");
                     this._loadingElement.style.display = "none";
                     this._loadingElement.remove();
                 }
@@ -148,6 +154,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
     }
 
     private createLoadingElement(existing?: HTMLElement): HTMLElement {
+    if(debug && !existing) console.log("Creating loading element");
         this._loadingElement = existing || document.createElement("div");
         if (!existing) {
             this._loadingElement.style.position = "fixed";
@@ -165,7 +172,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
             this._loadingElement.style.color = "white";
         }
 
-        const className = this._loadingElementOptions?.className ?? "loading";
+        const className = this._loadingElementOptions?.className ?? EngineLoadingView.LoadingContainerClassName;
         this._loadingElement.classList.add(className);
         if (this._loadingElementOptions?.additionalClasses) {
             for (const c of this._loadingElementOptions.additionalClasses) {

package/src/engine/engine_element_overlay.ts

@@ -1,6 +1,7 @@
 import { Context } from "./engine_setup";
-import { isMozillaXR } from "./engine_utils";
+import { getParam, isMozillaXR } from "./engine_utils";
 
+const debug = getParam("debugaroverlay");
 export const arContainerClassName = "ar";
 export const quitARClassName = "quit-ar";
 
@@ -110,7 +111,8 @@ export class AROverlayHandler {
         if (arElements && arElements.length > 0)
             return arElements[0] as HTMLElement;
 
-        console.log("No overlay container found in document - generating new ony");
+        if (debug)
+            console.log("No overlay container found in document - generating new ony");
         const el = document.createElement("div");
         el.classList.add(arContainerClassName);
         el.style.position = "absolute";

package/src/engine/engine_input.ts

@@ -384,6 +384,8 @@ export class Input extends EventTarget {
         for (let i = 0; i < evt.changedTouches.length; i++) {
             const touch = evt.changedTouches[i];
             const id = this.getPointerIndex(touch.identifier)
+            if (debug)
+                showBalloonMessage(`touch start #${id}, identifier:${touch.identifier}`);
             const args: PointerEventArgs = { button: id, clientX: touch.clientX, clientY: touch.clientY, pointerType: PointerType.Touch, source: evt };
             this.onDown(args);
         }
@@ -404,6 +406,8 @@ export class Input extends EventTarget {
         for (let i = 0; i < evt.changedTouches.length; i++) {
             const touch = evt.changedTouches[i];
             const id = this.getPointerIndex(touch.identifier)
+            if (debug)
+                showBalloonMessage(`touch up #${id}, identifier:${touch.identifier}`);
             const args: PointerEventArgs = { button: id, clientX: touch.clientX, clientY: touch.clientY, pointerType: PointerType.Touch, source: evt };
             this.onUp(args);
         }

package/src/engine/engine_networking_websocket.ts

@@ -1 +1,3 @@
-// TODO: move websocket specific networking code here!
+// TODO: move websocket specific networking code here!
+
+export {}

package/src/engine/engine_serialization_builtin_serializer.ts

@@ -6,6 +6,7 @@ import { debugExtension } from "./engine_default_parameters";
 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";
 
 // export class SourcePath {
 //     src?:string
@@ -98,7 +99,8 @@ class ObjectSerializer extends TypeSerializer {
                     res = GameObject.findByGuid(data.guid, context.context.scene);
                 }
                 if (!res) {
-                    console.warn("Could not resolve object reference", context.path, data, context.target, context.context.scene);
+                    if (isDevEnvironment() || debugExtension)
+                        console.warn("Could not resolve object reference", context.path, data, context.target, context.context.scene);
                     data["could_not_resolve"] = true;
                 }
                 else if (debugExtension)
@@ -141,9 +143,10 @@ class ComponentSerializer extends TypeSerializer {
                 // if not found within the gltf use the provided context scene
                 // to find references outside
                 res = this.findObjectForGuid(data.guid, context.context?.scene);
-                if(res) return res;
+                if (res) return res;
             }
-            console.warn("Could not resolve component reference", context.path, data, context.target);
+            if (isDevEnvironment() || debugExtension)
+                console.warn("Could not resolve component reference", context.path, data, context.target);
             data["could_not_resolve"] = true;
             return undefined;
         }
@@ -227,7 +230,7 @@ class EventListSerializer extends TypeSerializer {
                                 call.method = call.method.substring(4);
                                 if (target[call.method] !== undefined) foundMethod = true;
                             }
-                            if (!foundMethod)
+                            if (!foundMethod && (isDevEnvironment() || debugExtension))
                                 printWarningMethodNotFound();
                         }
                     }
@@ -302,7 +305,7 @@ export class RenderTextureSerializer extends TypeSerializer {
     }
 
     onDeserialize(data: any, context: SerializationContext) {
-        if(data instanceof Texture && context.type === RenderTexture){
+        if (data instanceof Texture && context.type === RenderTexture) {
             const tex = data as Texture;
             const rt = new RenderTexture(tex.image.width, tex.image.height);
             rt.texture = tex;

package/src/engine/engine_utils.ts

@@ -52,7 +52,7 @@ export function getUrlParams() {
     return new URLSearchParams(window.location.search);
 }
 
-export function getParam(paramName: string): string | boolean {
+export function getParam(paramName: string): string | boolean | number {
 
     if (saveParams && !requestedParams.includes(paramName))
         requestedParams.push(paramName);
@@ -60,6 +60,8 @@ export function getParam(paramName: string): string | boolean {
     if (urlParams.has(paramName)) {
         const val = urlParams.get(paramName);
         if (val) {
+            const num = Number(val);
+            if (!isNaN(num)) return num; 
             return val;
         }
         else return true;

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 { getParam, getPath } from "../engine_utils";
+import { delay, getParam, getPath } from "../engine_utils";
 
 export const EXTENSION_NAME = "NEEDLE_progressive";
 
@@ -14,6 +14,7 @@ declare type ProgressiveTextureSchema = {
     guid: string;
 }
 
+
 const debug_toggle_maps: Map<Material, { [key: string]: { original: Texture, lod0: Texture } }> = new Map();
 let show_lod0 = false;
 if (debug) {
@@ -71,7 +72,6 @@ export class NEEDLE_progressive implements GLTFLoaderPlugin {
         }
     }
 
-
     get name(): string {
         return EXTENSION_NAME;
     }
@@ -125,6 +125,7 @@ export class NEEDLE_progressive implements GLTFLoaderPlugin {
 
     private static cache = new Map<string, ProgressiveTextureSchema>();
     private static resolved: { [key: string]: Texture } = {};
+    private static currentlyLoading: { [key: string]: Promise<Texture | null> } = {};
 
     private static async getOrLoadTexture(context: Context, source: SourceIdentifier | undefined, material: Material, slot: string, current: Texture, _level: number): Promise<Texture | null> {
 
@@ -145,53 +146,82 @@ export class NEEDLE_progressive implements GLTFLoaderPlugin {
                     return this.resolved[resolveKey];
                 }
 
-                const loader = new GLTFLoader();
-                addDracoAndKTX2Loaders(loader, context);
-                if (debug) console.log("Load " + uri, material.name, slot, ext.guid);
-                const gltf = await loader.loadAsync(uri);
-                const parser = gltf.parser;
-                if (debug) console.log("Loading finished " + uri, material.name, slot, ext.guid);
-                let index = -1;
-                let found = false;
-                for (const tex of gltf.parser.json.textures) {
-                    index++;
-                    if (tex?.extensions) {
-                        const other: ProgressiveTextureSchema = tex?.extensions[EXTENSION_NAME];
-                        if (other?.guid) {
-                            if (other.guid === ext.guid) {
-                                found = true;
-                                break;
-                                // if (debug)
-                                //     console.log(material.name, slot, "change \"" + current.name + "\" → \"" + tex.name + "\"", uri, index, tex, material);
-                                // this.resolved[resolveKey] = tex as Texture;
-                                // return tex;
+                const info = this.onProgressiveLoadStart(context, source, uri, material, slot);
+                try {
+                    if(this.currentlyLoading[resolveKey] !== undefined) {
+                        if(debug)
+                            console.log("Already loading:", material.name + "." + slot, resolveKey);
+                        const tex = await this.currentlyLoading[resolveKey];
+                        return tex;
+                    }
+                    const request = new Promise<Texture | null>(async (resolve, _) => {
+                        const loader = new GLTFLoader();
+                        addDracoAndKTX2Loaders(loader, context);
+
+                        if (debug) console.log("Load " + uri, material.name, slot, ext.guid);
+                        if (debug) {
+                            await delay(Math.random() * 1000);
+                        }
+
+                        const gltf = await loader.loadAsync(uri);
+                        const parser = gltf.parser;
+                        if (debug) console.log("Loading finished " + uri, material.name, slot, ext.guid);
+                        let index = -1;
+                        let found = false;
+                        for (const tex of gltf.parser.json.textures) {
+                            index++;
+                            if (tex?.extensions) {
+                                const other: ProgressiveTextureSchema = tex?.extensions[EXTENSION_NAME];
+                                if (other?.guid) {
+                                    if (other.guid === ext.guid) {
+                                        found = true;
+                                        break;
+                                    }
+                                }
                             }
                         }
-                    }
-                }
-                if (!found)
-                    return null;
+                        if (!found)
+                            return resolve(null);
 
-                // const index = Number.parseInt(ext.pointer.substring("textures/".length));
-                const tex = await parser.getDependency("texture", index);
-                tex.encoding = current.encoding;
-                if (tex) {
-                    tex.guid = ext.guid;
+                        const tex = await parser.getDependency("texture", index);
+                        tex.encoding = current.encoding;
+                        if (tex) {
+                            tex.guid = ext.guid;
+                        }
+                        this.resolved[resolveKey] = tex as Texture;
+                        if (debug)
+                            console.log(material.name, slot, "change \"" + current.name + "\" → \"" + tex.name + "\"", uri, index, tex, material, resolveKey);
+                        resolve(tex);
+                    });
+                    this.currentlyLoading[resolveKey] = request;
+                    const tex = await request;
+                    return tex;
+                }
+                finally {
+                    delete this.currentlyLoading[resolveKey];
+                    this.onProgressiveLoadEnd(info);
                 }
-                this.resolved[resolveKey] = tex as Texture;
-                if (debug)
-                    console.log(material.name, slot, "change \"" + current.name + "\" → \"" + tex.name + "\"", uri, index, tex, material, resolveKey);
-                return tex;
             }
             else {
-                if (debug) console.log("Load texture from uri: " + uri);
-                const loader = new TextureLoader();
-                const loaded = await loader.loadAsync(uri);
-                if (loaded && debug) {
-                    console.log(ext, loaded);
+                const info = this.onProgressiveLoadStart(context, source, uri, material, slot);
+                try {
+                    if (debug) console.log("Load texture from uri: " + uri);
+                    const loader = new TextureLoader();
+                    const tex = await loader.loadAsync(uri);
+                    if (tex) {
+                        (tex as any).guid = ext.guid;
+                        tex.flipY = false;
+                        tex.needsUpdate = true;
+                        tex.encoding = current.encoding;
+                        if (debug)
+                            console.log(ext, tex);
+                    }
+                    else if (debug) console.warn("failed loading", uri);
+                    return tex;
+                }
+                finally {
+                    this.onProgressiveLoadEnd(info);
                 }
-                else console.warn("failed loading", uri);
-                return loaded;
             }
             // loader.then((h: Texture) => {
             //     // console.log(t, h);
@@ -212,4 +242,116 @@ export class NEEDLE_progressive implements GLTFLoaderPlugin {
         }
         return null;
     }
-}
+
+
+    /** subscribe to events whenever a loading event starts, invoked for every single loading process that starts */
+    static beginListenStart(context: Context, evt: ProgressiveLoadingEvent) {
+        if (!this._progressiveEventListeners.has(context)) {
+            this._progressiveEventListeners.set(context, new ProgressiveLoadingEventHandler());
+        }
+        this._progressiveEventListeners.get(context)!.start.push(evt);
+    }
+    static stopListenStart(context: Context, evt: ProgressiveLoadingEvent) {
+        if (!this._progressiveEventListeners.has(context)) {
+            return;
+        }
+        const listeners = this._progressiveEventListeners.get(context)!.start;
+        const index = listeners.indexOf(evt);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+    }
+
+    /** subscribe to loading event ended event */
+    static beginListenEnd(context: Context, evt: ProgressiveLoadingEvent) {
+        if (!this._progressiveEventListeners.has(context)) {
+            this._progressiveEventListeners.set(context, new ProgressiveLoadingEventHandler());
+        }
+        this._progressiveEventListeners.get(context)!.end.push(evt);
+    }
+    static stopListenEnd(context: Context, evt: ProgressiveLoadingEvent) {
+        if (!this._progressiveEventListeners.has(context)) {
+            return;
+        }
+        const listeners = this._progressiveEventListeners.get(context)!.end;
+        const index = listeners.indexOf(evt);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+    }
+
+    /** event listeners per context */
+    private static _progressiveEventListeners: Map<Context, ProgressiveLoadingEventHandler> = new Map();
+    //** loading info per context, contains an array of urls that are currently being loaded */
+    private static _currentProgressiveLoadingInfo: Map<Context, ProgressiveLoadingInfo[]> = new Map();
+
+    // called whenever a progressive loading event starts
+    private static onProgressiveLoadStart(context: Context, source: SourceIdentifier | undefined, uri: string, material: Material, slot: string): ProgressiveLoadingInfo {
+        if (!this._currentProgressiveLoadingInfo.has(context)) {
+            this._currentProgressiveLoadingInfo.set(context, []);
+        }
+        const info = new ProgressiveLoadingInfo(context, source, uri, material, slot);
+        const current = this._currentProgressiveLoadingInfo.get(context)!;
+        const listener = this._progressiveEventListeners.get(context);
+        if (listener) listener.onStart(info);
+
+        current.push(info);
+        return info;
+    }
+
+    private static onProgressiveLoadEnd(info: ProgressiveLoadingInfo) {
+        if (!info) return;
+        const context = info.context;
+        if (!this._currentProgressiveLoadingInfo.has(context)) {
+            return;
+        }
+        const current = this._currentProgressiveLoadingInfo.get(context)!;
+        const index = current.indexOf(info);
+        if (index < 0) {
+            return;
+        }
+        current.splice(index, 1);
+        const listener = this._progressiveEventListeners.get(context);
+        if (listener) listener.onEnd(info);
+    }
+}
+
+
+/** info object that holds information about a file that is currently being loaded */
+export class ProgressiveLoadingInfo {
+    readonly context: Context;
+    readonly source: SourceIdentifier | undefined;
+    readonly uri: string;
+    readonly material?: Material;
+    readonly slot?: string;
+    // TODO: can contain information if the event is a background process / preloading or if the object is currently visible
+
+    constructor(context: Context, source: SourceIdentifier | undefined, uri: string, material?: Material, slot?: string) {
+        this.context = context;
+        this.source = source;
+        this.uri = uri;
+        this.material = material;
+        this.slot = slot;
+    }
+};
+
+
+export declare type ProgressiveLoadingEvent = (info: ProgressiveLoadingInfo) => void;
+
+/** progressive loading event handler implementation */
+class ProgressiveLoadingEventHandler {
+    start: ProgressiveLoadingEvent[] = [];
+    end: ProgressiveLoadingEvent[] = [];
+
+    onStart(listener: ProgressiveLoadingInfo) {
+        for (const l of this.start) {
+            l(listener);
+        }
+    }
+
+    onEnd(listener: ProgressiveLoadingInfo) {
+        for (const l of this.end) {
+            l(listener);
+        }
+    }
+}

package/src/engine-components/GroundProjection.ts

@@ -7,6 +7,9 @@ import { Texture } from "three";
 
 export class GroundProjectedEnv extends Behaviour {
 
+    @serializable()
+    applyOnAwake: boolean = false;
+
     @serializable()
     set scale(val: number) {
         this._scale = val;
@@ -40,14 +43,23 @@ export class GroundProjectedEnv extends Behaviour {
     private _watcher?: Watch;
 
 
-    onEnable() {
-        // TODO: if we do this in the first frame we can not disable it again. Something buggy with the watch?!
-        if (this.context.time.frameCount > 0)
+    awake() {
+        if (this.applyOnAwake)
             this.updateAndCreate();
     }
 
-    start() {
-        this.updateAndCreate();
+    onEnable() {
+        // TODO: if we do this in the first frame we can not disable it again. Something buggy with the watch?!
+        if (this.context.time.frameCount > 0) {
+            if (this.applyOnAwake)
+                this.updateAndCreate();
+        }
+        if (!this._watcher) {
+            this._watcher = new Watch(this.context.scene, "environment");
+            this._watcher.subscribeWrite(_ => {
+                this.updateProjection();
+            });
+        }
     }
 
     onDisable() {
@@ -57,13 +69,7 @@ export class GroundProjectedEnv extends Behaviour {
 
     private updateAndCreate() {
         this.updateProjection();
-        if (!this._watcher) {
-            this._watcher = new Watch(this.context.scene, "environment");
-            this._watcher.subscribeWrite(_ => {
-                this.updateProjection();
-            });
-        }
-        this._watcher.apply();
+        this._watcher?.apply();
     }
 
     updateProjection() {

package/src/engine-components/ParticleSystemModules.ts

@@ -517,9 +517,9 @@ export class ShapeModule implements EmitterShape {
     private readonly _worldSpaceMatrixInverse: Matrix4 = new Matrix4();
 
 
-    constructor() {
-        // console.log(this);
-    }
+    // constructor() {
+    //     console.log(this);
+    // }
 
     update(system: IParticleSystem, _context: Context, simulationSpace: ParticleSystemSimulationSpace, obj: Object3D) {
         this.system = system;
@@ -534,6 +534,16 @@ export class ShapeModule implements EmitterShape {
         }
     }
 
+    private updateRotation() {
+        const isRotated = this.rotation.x !== 0 || this.rotation.y !== 0 || this.rotation.z !== 0;
+        if (isRotated) {
+            this._rotation.x = Mathf.toRadians(this.rotation.x);
+            this._rotation.y = -Mathf.toRadians(this.rotation.y);
+            this._rotation.z = -Mathf.toRadians(this.rotation.z);
+        }
+        return isRotated;
+    }
+
     /** nebula implementations: */
 
     /** initializer implementation */
@@ -544,61 +554,52 @@ export class ShapeModule implements EmitterShape {
         return this._vector;
     }
     getPosition(): void {
-        if (!this.enabled) {
-            this._vector.set(0, 0, 0);
-            return;
-        }
+        this._vector.set(0, 0, 0);
         const pos = this._temp.copy(this.position);
         const isWorldSpace = this._space === ParticleSystemSimulationSpace.World;
         if (isWorldSpace) {
             pos.applyQuaternion(this.system.worldQuaternion);
         }
-
-        const isRotated = this.rotation.x !== 0 || this.rotation.y !== 0 || this.rotation.z !== 0;
-        if (isRotated) {
-            this._rotation.x = Mathf.toRadians(this.rotation.x);
-            this._rotation.y = -Mathf.toRadians(this.rotation.y);
-            this._rotation.z = -Mathf.toRadians(this.rotation.z);
-        }
-
         let radius = this.radius;
         if (isWorldSpace) radius *= this.system.worldScale.x;
-        switch (this.shapeType) {
-            case ParticleSystemShapeType.Box:
-                this._vector.x = Math.random() * this.scale.x - this.scale.x / 2;
-                this._vector.y = Math.random() * this.scale.y - this.scale.y / 2;
-                this._vector.z = Math.random() * this.scale.z - this.scale.z / 2;
-                this._vector.add(pos);
-                break;
-            case ParticleSystemShapeType.Cone:
-                this.randomConePoint(this.position, this.angle, radius, this.radiusThickness, this.arc, this.arcMode, this._vector);
-                break;
-            case ParticleSystemShapeType.Sphere:
-                this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
-                this._vector.x *= this.scale.x;
-                this._vector.y *= this.scale.y;
-                this._vector.z *= this.scale.z;
-                break;
-            case ParticleSystemShapeType.Circle:
-                this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
-                this._vector.x *= this.scale.x;
-                this._vector.y *= this.scale.y;
-                this._vector.z *= 0;
-                break;
-            default:
-                this._vector.set(0, 0, 0);
-                break;
-            // case ParticleSystemShapeType.Hemisphere:
-            //     randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, 180, this._vector);
-            //     break;
-        }
+        if (this.enabled) {
+            switch (this.shapeType) {
+                case ParticleSystemShapeType.Box:
+                    this._vector.x = Math.random() * this.scale.x - this.scale.x / 2;
+                    this._vector.y = Math.random() * this.scale.y - this.scale.y / 2;
+                    this._vector.z = Math.random() * this.scale.z - this.scale.z / 2;
+                    this._vector.add(pos);
+                    break;
+                case ParticleSystemShapeType.Cone:
+                    this.randomConePoint(this.position, this.angle, radius, this.radiusThickness, this.arc, this.arcMode, this._vector);
+                    break;
+                case ParticleSystemShapeType.Sphere:
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
+                    this._vector.x *= this.scale.x;
+                    this._vector.y *= this.scale.y;
+                    this._vector.z *= this.scale.z;
+                    break;
+                case ParticleSystemShapeType.Circle:
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
+                    this._vector.x *= this.scale.x;
+                    this._vector.y *= this.scale.y;
+                    this._vector.z *= 0;
+                    break;
+                default:
+                    this._vector.set(0, 0, 0);
+                    break;
+                // case ParticleSystemShapeType.Hemisphere:
+                //     randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, 180, this._vector);
+                //     break;
+            }
 
-        this.randomizePosition(this._vector, this.randomPositionAmount);
+            this.randomizePosition(this._vector, this.randomPositionAmount);
+        }
 
-        if (isRotated)
+        if (this.updateRotation())
             this._vector.applyEuler(this._rotation);
 
-        if (this._space === ParticleSystemSimulationSpace.World) {
+        if (isWorldSpace) {
             this._vector.add(this.system.worldPos);
         }
     }
@@ -634,6 +635,8 @@ export class ShapeModule implements EmitterShape {
         if (this._space === ParticleSystemSimulationSpace.World) {
             this._dir.applyMatrix4(this._worldSpaceMatrixInverse);
         }
+        if (this.updateRotation())
+            this._dir.applyEuler(this._rotation);
         this._dir.normalize();
         this.spherizeDirection(this._dir, this.sphericalDirectionAmount);
         this.randomizeDirection(this._dir, this.randomDirectionAmount);