@needle-tools/engine 2.24.0-pre

package/src/engine-components/ParticleSystemModules.ts

@@ -0,0 +1,173 @@
+import * as THREE from "three";
+
+export class MainModule {
+    randomizeRotationDirection: number = 0;
+    duration: number = 5;
+    loop: boolean = true;
+    prewarm: boolean = false;
+    startDelay = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startDelayMultiplier: number = 0;
+    startLifetime = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startLifetimeMultiplier: number = 5;
+    startSpeed = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startSpeedMultiplier: number = 5;
+    startSize3D: boolean = false;
+    startSize = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startSizeMultiplier: number = 1;
+    startSizeX = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startSizeXMultiplier: number = 1;
+    startSizeY = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startSizeYMultiplier: number = 1;
+    startSizeZ = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startSizeZMultiplier: number = 1;
+    startRotation3D: boolean = false;
+    startRotation = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startRotationMultiplier: number = 0;
+    startRotationX = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startRotationXMultiplier: number = 0;
+    startRotationY = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startRotationYMultiplier: number = 0;
+    startRotationZ = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    startRotationZMultiplier: number = 0;
+    flipRotation: number = 0;
+    startColor : THREE.Color = new THREE.Color(1, 1, 1);
+    startColor1 : THREE.Color | undefined = new THREE.Color(0, 0, 0); // this only exists in gradient mode
+    gravityModifier = undefined; // UnityEngine.ParticleSystem+MinMaxCurve
+    gravityModifierMultiplier: number = 0;
+    simulationSpace: number = 0;
+    customSimulationSpace = null;
+    simulationSpeed: number = 1;
+    useUnscaledTime: boolean = false;
+    scalingMode: number = 1;
+    playOnAwake: boolean = true;
+    maxParticles: number = 1000;
+    emitterVelocityMode: number = 1;
+    stopAction: number = 0;
+    ringBufferMode: number = 0;
+    ringBufferLoopRange: THREE.Vector2 = new THREE.Vector2(0, 1);
+    cullingMode: number = 0;
+}
+
+
+export class EmissionModule {
+    burstCount: number = 0;
+    enabled: boolean = true;
+    rate: number = 10;
+    rateMutliplier: number = 1;
+    rateOverDistance: number = 0;
+    rateOverDistanceMultiplier: number = 0;
+    rateOverTime: number = 0;
+    rateOverTimeMultiplier: number = 0;
+    // type: number = 0; // is obsolete, time and emission are both active
+}
+
+export class ShapeModule {
+    shapeType : ParticleSystemShapeType = ParticleSystemShapeType.Box;
+    enabled: boolean = true;
+    alignToDirection: boolean = false;
+    angle: number = 0;
+    arc: number = 360;
+    arcmode: number = 0; // TODO: enum?
+    // arcSpeed, arcSpeedMult, arcSpread
+    box: THREE.Vector3 = new THREE.Vector3(1, 1, 1);
+    boxThickness: THREE.Vector3 = new THREE.Vector3(0, 0, 0);
+    position : THREE.Vector3 = new THREE.Vector3(0, 0, 0);
+    rotation : THREE.Vector3 = new THREE.Vector3(0, 0, 0);
+    scale : THREE.Vector3 = new THREE.Vector3(1, 1, 1);
+
+    radius : number = 1;
+    sphericalDirectionAmount : number = 0;
+}
+
+
+/// <summary>
+///   <para>The emission shape.</para>
+/// </summary>
+export enum ParticleSystemShapeType {
+    /// <summary>
+    ///   <para>Emit from a sphere.</para>
+    /// </summary>
+    Sphere = 0,
+    /// <summary>
+    ///   <para>Emit from the surface of a sphere.</para>
+    /// </summary>
+    // [Obsolete("SphereShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] SphereShell,
+    SphereShell,
+    /// <summary>
+    ///   <para>Emit from a half-sphere.</para>
+    /// </summary>
+    Hemisphere,
+    // / <summary>
+    // /   <para>Emit from the surface of a half-sphere.</para>
+    // / </summary>
+    // [Obsolete("HemisphereShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] HemisphereShell,
+    HemisphereShell,
+    /// <summary>
+    ///   <para>Emit from the base of a cone.</para>
+    /// </summary>
+    Cone,
+    /// <summary>
+    ///   <para>Emit from the volume of a box.</para>
+    /// </summary>
+    Box = 5,
+    /// <summary>
+    ///   <para>Emit from a mesh.</para>
+    /// </summary>
+    Mesh,
+    /// <summary>
+    ///   <para>Emit from the base surface of a cone.</para>
+    /// </summary>
+    // [Obsolete("ConeShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] ConeShell,
+    // /// <summary>
+    // ///   <para>Emit from a cone.</para>
+    // /// </summary>
+    ConeVolume,
+    /// <summary>
+    ///   <para>Emit from the surface of a cone.</para>
+    /// </summary>
+    // [Obsolete("ConeVolumeShell is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] ConeVolumeShell,
+    // /// <summary>
+    // ///   <para>Emit from a circle.</para>
+    // /// </summary>
+    Circle = 10,
+    /// <summary>
+    ///   <para>Emit from the edge of a circle.</para>
+    /// </summary>
+    // [Obsolete("CircleEdge is deprecated and does nothing. Please use ShapeModule.radiusThickness instead, to control edge emission.", false)] CircleEdge,
+    // /// <summary>
+    // ///   <para>Emit from an edge.</para>
+    // /// </summary>
+    SingleSidedEdge,
+    /// <summary>
+    ///   <para>Emit from a mesh renderer.</para>
+    /// </summary>
+    MeshRenderer,
+    /// <summary>
+    ///   <para>Emit from a skinned mesh renderer.</para>
+    /// </summary>
+    SkinnedMeshRenderer,
+    /// <summary>
+    ///   <para>Emit from the surface of a box.</para>
+    /// </summary>
+    BoxShell,
+    /// <summary>
+    ///   <para>Emit from the edges of a box.</para>
+    /// </summary>
+    BoxEdge,
+    /// <summary>
+    ///   <para>Emit from a Donut.</para>
+    /// </summary>
+    Donut,
+    /// <summary>
+    ///   <para>Emit from a rectangle.</para>
+    /// </summary>
+    Rectangle,
+    /// <summary>
+    ///   <para>Emit from a sprite.</para>
+    /// </summary>
+    Sprite,
+    /// <summary>
+    ///   <para>Emit from a sprite renderer.</para>
+    /// </summary>
+    SpriteRenderer,
+}

package/src/engine-components/PlayerColor.ts

@@ -0,0 +1,93 @@
+import { RoomEvents } from "../engine/engine_networking";
+import { Behaviour, GameObject } from "./Component";
+import * as THREE from "three";
+import { AvatarMarker } from "./WebXRAvatar";
+import { WaitForSeconds } from "../engine/engine_coroutine";
+
+
+export class PlayerColor extends Behaviour {
+
+    awake(): void {
+        // console.log("AWAKE", this.name);
+        this.context.connection.beginListen(RoomEvents.JoinedRoom, this.tryAssignColor.bind(this));
+    }
+
+    private _didAssignPlayerColor: boolean = false;
+
+    onEnable(): void {
+        // console.log("ENABLE", this.name);
+        if (!this._didAssignPlayerColor)
+            this.startCoroutine(this.waitForConnection());
+    }
+
+    private *waitForConnection() {
+        while (!this.destroyed && this.enabled) {
+            yield WaitForSeconds(.2);
+            if (this.tryAssignColor()) break;
+        }
+        // console.log("STOP WAITING", this.name, this.destroyed);
+    }
+
+    private tryAssignColor(): boolean {
+        const marker = GameObject.getComponentInParent(this.gameObject, AvatarMarker);
+        if (marker && marker.connectionId) {
+            this._didAssignPlayerColor = true;
+            this.assignUserColor(marker.connectionId);
+            return true;
+        }
+        return false;
+    }
+
+    assignUserColor(id: string) {
+
+        // console.log(this.name, id, this);
+
+        const hash = PlayerColor.hashCode(id);
+        const color = PlayerColor.colorFromHashCode(hash);
+        if (this.gameObject.type === "Mesh") {
+            const mesh: THREE.Mesh = this.gameObject as any;
+            this.assignColor(color, id, mesh);
+        }
+        else if (this.gameObject.children) {
+            for (const ch of this.gameObject.children) {
+                const obj = ch as any;
+                if (obj.material && obj.material.color) {
+                    this.assignColor(color, id, obj);
+                }
+            }
+        }
+    }
+
+    private assignColor(col: THREE.Color, id: string, mesh: THREE.Mesh) {
+        let mat = mesh.material as THREE.Material;
+        if (!mat) return;
+        if (mat["_playerMaterial"] !== id) {
+            // console.log("ORIG", mat);
+            mat = mat.clone();
+            mat["_playerMaterial"] = id;
+            mesh.material = mat;
+            // console.log("CLONE", mat);
+        }
+        else console.log("DONT CLONE", mat);
+        mat["color"] = col;
+    }
+
+    public static hashCode(str: string) {
+        var hash = 0, i, chr;
+        if (str.length === 0) return hash;
+        for (i = 0; i < str.length; i++) {
+            chr = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + chr;
+            hash |= 0; // Convert to 32bit integer
+        }
+        return hash;
+    };
+
+    public static colorFromHashCode(hash: number) {
+        const r = (hash & 0xFF0000) >> 16;
+        const g = (hash & 0x00FF00) >> 8;
+        const b = hash & 0x0000FF;
+        return new THREE.Color(r / 255, g / 255, b / 255);
+    }
+}
+