@needle-tools/engine 2.39.0-pre → 2.41.0-pre

package/dist/needle-engine.d.ts

@@ -1,12 +1,15 @@
 declare module "engine/engine_math" {
     class MathHelper {
         random(): number;
-        clamp(value: any, min: any, max: any): any;
-        clamp01(value: any): any;
-        lerp(value1: any, value2: any, amount: any): any;
-        moveTowards(value1: any, value2: any, amount: any): any;
-        toDegrees(radians: any): number;
-        toRadians(degrees: any): number;
+        clamp(value: number, min: number, max: number): number;
+        clamp01(value: number): number;
+        lerp(value1: number, value2: number, amount: number): number;
+        remap(value: number, min1: number, max1: number, min2: number, max2: number): number;
+        moveTowards(value1: number, value2: number, amount: number): number;
+        toDegrees(radians: number): number;
+        toRadians(degrees: number): number;
+        gammaToLinear(gamma: number): number;
+        linearToGamma(linear: number): number;
     }
     const Mathf: MathHelper;
     export { Mathf };
@@ -48,6 +51,28 @@ declare module "engine/engine_physics.types" {
         All = -1
     }
 }
+declare module "engine/engine_three_utils" {
+    import * as THREE from "three";
+    import { Vector3 } from "three";
+    export function lookAtInverse(obj: THREE.Object3D, target: Vector3): void;
+    export function getWorldPosition(obj: THREE.Object3D, vec?: THREE.Vector3 | null, updateParents?: boolean): THREE.Vector3;
+    export function setWorldPosition(obj: THREE.Object3D, val: THREE.Vector3): void;
+    export function setWorldPositionXYZ(obj: THREE.Object3D, x: number, y: number, z: number): void;
+    export function getWorldQuaternion(obj: THREE.Object3D, target?: THREE.Quaternion | null): THREE.Quaternion;
+    export function setWorldQuaternion(obj: THREE.Object3D, val: THREE.Quaternion): void;
+    export function setWorldQuaternionXYZW(obj: THREE.Object3D, x: number, y: number, z: number, w: number): void;
+    export function getWorldScale(obj: THREE.Object3D, vec?: THREE.Vector3 | null): THREE.Vector3;
+    export function setWorldScale(obj: THREE.Object3D, vec: THREE.Vector3): void;
+    export function forward(obj: THREE.Object3D): THREE.Vector3;
+    export function getWorldEuler(obj: THREE.Object3D): THREE.Euler;
+    export function setWorldEuler(obj: THREE.Object3D, val: THREE.Euler): void;
+    export function getWorldRotation(obj: THREE.Object3D): THREE.Vector3;
+    export function setWorldRotation(obj: THREE.Object3D, val: THREE.Vector3): void;
+    export function setWorldRotationXYZ(obj: THREE.Object3D, x: number, y: number, z: number, degrees?: boolean): void;
+    export function logHierarchy(root: THREE.Object3D | null | undefined, collapsible?: boolean): void;
+    export function copyTexture(texture: THREE.Texture): THREE.Texture;
+    export function textureToCanvas(texture: THREE.Texture, force?: boolean): HTMLCanvasElement | null;
+}
 declare module "engine/engine_types" {
     import { Camera, Color, Material, Object3D, Vector3, Quaternion } from "three";
     import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
@@ -160,20 +185,26 @@ declare module "engine/engine_types" {
     export type ICollisionContext = {
         getCollider(obj: Object3D): ICollider;
     };
-    export type Vec3 = {
+    export type Vec2 = {
         x: number;
         y: number;
-        z: number;
     };
-    export type Vec2 = {
+    export type Vec3 = {
         x: number;
         y: number;
+        z: number;
     };
     export class ContactPoint {
-        readonly localPoint: Vec3;
+        private readonly _point;
+        private readonly _normal;
         readonly distance: number;
-        readonly normal: Vec3;
-        constructor(localPt: Vec3, dist: number, normal: Vec3);
+        readonly impulse: number;
+        readonly friction: number;
+        /** worldspace point */
+        get point(): Vector3;
+        /** worldspace normal */
+        get normal(): Vector3;
+        constructor(point: Vec3, dist: number, normal: Vec3, impulse: number, friction: number);
     }
     export class Collision {
         readonly contacts: ContactPoint[];
@@ -194,6 +225,14 @@ declare module "engine/engine_utils" {
     export const nameofFactory: <T>() => (name: keyof T) => keyof T;
     export function nameof<T>(name: keyof T): keyof T;
     export function isDebugMode(): boolean;
+    export class CircularBuffer<T> {
+        private _factory;
+        private _cache;
+        private _maxSize;
+        private _index;
+        constructor(factory: () => T, maxSize: number);
+        get(): T;
+    }
     export function getUrlParams(): URLSearchParams;
     export function getParam(paramName: string): string | boolean;
     export function setParam(paramName: string, paramValue: string): void;
@@ -225,6 +264,7 @@ declare module "engine/engine_utils" {
         revoke(): void;
         dispose(): void;
     }
+    export function isMobileDevice(): boolean;
 }
 declare module "engine/extensions/extension_resolver" {
     import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
@@ -389,6 +429,7 @@ declare module "engine/engine_serialization_core" {
 declare module "engine/engine_input" {
     import * as THREE from 'three';
     import { Context } from "engine/engine_setup";
+    import { Vec2 } from "engine/engine_types";
     export type PointerEventArgs = {
         button: number;
         clientX: number;
@@ -470,6 +511,7 @@ declare module "engine/engine_input" {
         createPointerDown(args: PointerEventArgs): void;
         createPointerMove(args: PointerEventArgs): void;
         createPointerUp(args: PointerEventArgs): void;
+        convertScreenspaceToRaycastSpace(vec2: Vec2): void;
         constructor(context: Context);
         private onLostFocus;
         private onEndOfFrame;
@@ -580,28 +622,6 @@ declare module "engine/engine_input" {
         F12 = "F12"
     }
 }
-declare module "engine/engine_three_utils" {
-    import * as THREE from "three";
-    import { Vector3 } from "three";
-    export function lookAtInverse(obj: THREE.Object3D, target: Vector3): void;
-    export function getWorldPosition(obj: THREE.Object3D, vec?: THREE.Vector3 | null, updateParents?: boolean): THREE.Vector3;
-    export function setWorldPosition(obj: THREE.Object3D, val: THREE.Vector3): void;
-    export function setWorldPositionXYZ(obj: THREE.Object3D, x: number, y: number, z: number): void;
-    export function getWorldQuaternion(obj: THREE.Object3D, target?: THREE.Quaternion | null): THREE.Quaternion;
-    export function setWorldQuaternion(obj: THREE.Object3D, val: THREE.Quaternion): void;
-    export function setWorldQuaternionXYZW(obj: THREE.Object3D, x: number, y: number, z: number, w: number): void;
-    export function getWorldScale(obj: THREE.Object3D, vec?: THREE.Vector3 | null): THREE.Vector3;
-    export function setWorldScale(obj: THREE.Object3D, vec: THREE.Vector3): void;
-    export function forward(obj: THREE.Object3D): THREE.Vector3;
-    export function getWorldEuler(obj: THREE.Object3D): THREE.Euler;
-    export function setWorldEuler(obj: THREE.Object3D, val: THREE.Euler): void;
-    export function getWorldRotation(obj: THREE.Object3D): THREE.Vector3;
-    export function setWorldRotation(obj: THREE.Object3D, val: THREE.Vector3): void;
-    export function setWorldRotationXYZ(obj: THREE.Object3D, x: number, y: number, z: number, degrees?: boolean): void;
-    export function logHierarchy(root: THREE.Object3D | null | undefined, collapsible?: boolean): void;
-    export function copyTexture(texture: THREE.Texture): THREE.Texture;
-    export function textureToCanvas(texture: THREE.Texture, force?: boolean): HTMLCanvasElement | null;
-}
 declare module "engine/engine_instancing" {
     export const NEED_UPDATE_INSTANCE_KEY: unique symbol;
     export class InstancingUtil {
@@ -746,10 +766,39 @@ declare module "engine/engine_gameobject" {
     export function foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive?: boolean): any;
     export function instantiate(instance: GameObject | Object3D | null, opts?: InstantiateOptions | null): GameObject | null;
 }
+declare module "engine/engine_gizmos" {
+    import * as THREE from 'three';
+    import { ColorRepresentation } from 'three';
+    import { Vec3 } from "engine/engine_types";
+    export class Gizmos {
+        static DrawRay(origin: Vec3, dir: Vec3, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+        static DrawDirection(pt: Vec3, direction: Vec3, color?: ColorRepresentation, duration?: number, depthTest?: boolean, lengthFactor?: number): void;
+        static DrawLine(pt0: {
+            x: number;
+            y: number;
+            z: number;
+        }, pt1: {
+            x: number;
+            y: number;
+            z: number;
+        }, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+        static DrawWireSphere(center: {
+            x: number;
+            y: number;
+            z: number;
+        }, radius: number, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+        static DrawSphere(center: {
+            x: number;
+            y: number;
+            z: number;
+        }, radius: number, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+    }
+    export function CreateWireCube(col?: THREE.ColorRepresentation | null): THREE.LineSegments;
+}
 declare module "engine/engine_physics" {
     import { Camera, Intersection, Layers, Mesh, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
     import { Context } from "engine/engine_setup";
-    import { IComponent, ICollider, IRigidbody } from "engine/engine_types";
+    import { IComponent, ICollider, IRigidbody, Vec3, Vec2 } from "engine/engine_types";
     import RAPIER, { RigidBody } from '@dimforge/rapier3d-compat';
     export type Rapier = typeof RAPIER;
     export class RaycastOptions {
@@ -786,7 +835,19 @@ declare module "engine/engine_physics" {
         private tempBoundingBox;
         private onSphereOverlap;
         raycastFromRay(ray: Ray, options?: RaycastOptions | null): Array<Intersection>;
+        /** raycast against rendered three objects. This might be very slow depending on your scene complexity.
+         * We recommend setting objects to IgnoreRaycast layer (2) when you don't need them to be raycasted.
+         * Raycasting SkinnedMeshes is specially expensive.
+         */
         raycast(options?: RaycastOptions | null): Array<Intersection>;
+        private rapierRay;
+        private raycastVectorsBuffer;
+        /** raycast against colliders */
+        raycastPhysicsFast(origin: Vec2 | Vec3, direction?: Vec3 | undefined, maxDistance?: number, solid?: boolean): null | {
+            point: Vector3;
+            collider: ICollider;
+        };
+        private getPhysicsRay;
         private _tempPosition;
         private _tempQuaternion;
         private _tempScale;
@@ -827,11 +888,17 @@ declare module "engine/engine_physics" {
         private getRigidbodyRelativeMatrix;
         private static centerConnectionPos;
         private static centerConnectionRot;
-        addFixedJoint(body1: IRigidbody, body2: IRigidbody, rel: {
+        addFixedJoint(body1: IRigidbody, body2: IRigidbody): void;
+        addHingeJoint(body1: IRigidbody, body2: IRigidbody, anchor: {
+            x: number;
+            y: number;
+            z: number;
+        }, axis: {
             x: number;
             y: number;
             z: number;
         }): void;
+        private calculateJointRelativeMatrices;
     }
 }
 declare module "engine/engine_time" {
@@ -1024,6 +1091,7 @@ declare module "engine/engine_networking" {
         leaveRoom(room?: string | null): void;
         send(key: string | OwnershipEvent, data?: IModel | object | boolean | null | string | number, queue?: SendQueue): void;
         sendDeleteRemoteState(guid: string): void;
+        sendDeleteRemoteStateAll(): void;
         sendBinary(bin: Uint8Array): void;
         private _defaultMessagesBuffer;
         private _defaultMessagesBufferArray;
@@ -1282,10 +1350,15 @@ declare module "engine-components/Component" {
         sourceId?: SourceIdentifier;
         /** called on a component with a map of old to new guids (e.g. when instantiate generated new guids and e.g. timeline track bindings needs to remape them) */
         resolveGuids?(guidsMap: GuidsMap): void;
+        /** called once when the component becomes active for the first time */
         awake(): void;
+        /** called every time when the component gets enabled (this is invoked after awake and before start) */
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
+        /** called when you decorate fields with the @validate() decorator
+         * @param field the name of the field that was changed
+         */
         onValidate?(prop?: string): void;
         start?(): void;
         earlyUpdate?(): void;
@@ -1303,18 +1376,31 @@ declare module "engine-components/Component" {
         stopCoroutine(routine: Generator, evt?: FrameEvent): void;
         get destroyed(): boolean;
         destroy(): void;
+        /** @internal */
         protected __didAwake: boolean;
+        /** @internal */
         private __didStart;
+        /** @internal */
         protected __didEnable: boolean;
+        /** @internal */
         protected __isEnabled: boolean | undefined;
+        /** @internal */
         private __destroyed;
+        /** @internal */
         get __internalDidAwakeAndStart(): boolean;
+        /** @internal */
         constructor();
+        /** @internal */
         __internalNewInstanceCreated(): void;
+        /** @internal */
         __internalAwake(): void;
+        /** @internal */
         __internalStart(): void;
+        /** @internal */
         __internalEnable(): boolean;
+        /** @internal */
         __internalDisable(): void;
+        /** @internal */
         __internalDestroy(): void;
         get enabled(): boolean;
         set enabled(val: boolean);
@@ -2389,6 +2475,7 @@ declare module "engine/api" {
     export { FrameEvent } from "engine/engine_setup";
     export * from "engine/debug/debug";
     export { validate } from "engine/engine_util_decorator";
+    export { Gizmos } from "engine/engine_gizmos";
 }
 declare module "engine-components/AlignmentConstraint" {
     import { Behaviour } from "engine-components/Component";
@@ -2576,10 +2663,6 @@ declare module "engine-components/BasicIKConstraint" {
         update(): void;
     }
 }
-declare module "engine/engine_gizmos" {
-    import * as THREE from 'three';
-    export function CreateWireCube(col?: THREE.ColorRepresentation | null): THREE.LineSegments;
-}
 declare module "engine-components/BoxHelperComponent" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
@@ -3927,7 +4010,6 @@ declare module "engine-components/Joints" {
         connectedBody?: Rigidbody;
         get rigidBody(): Rigidbody | null;
         private _rigidBody;
-        connectedAnchor?: Vector3;
         onEnable(): void;
         private create;
         protected abstract createJoint(self: Rigidbody, other: Rigidbody): any;
@@ -3935,6 +4017,11 @@ declare module "engine-components/Joints" {
     export class FixedJoint extends Joint {
         protected createJoint(self: Rigidbody, other: Rigidbody): void;
     }
+    export class HingeJoint extends Joint {
+        anchor?: Vector3;
+        axis?: Vector3;
+        protected createJoint(self: Rigidbody, other: Rigidbody): void;
+    }
 }
 declare module "engine-components/Light" {
     import { Behaviour } from "engine-components/Component";
@@ -4006,6 +4093,8 @@ declare module "engine-components/Light" {
         private onWebXREnded;
         createLight(): void;
         updateMainLightRoutine(): Generator<undefined, void, unknown>;
+        static allowChangingRendererShadowMapType: boolean;
+        private updateShadowSoftHard;
         private setDirectionalLight;
     }
 }
@@ -4069,62 +4158,178 @@ declare module "engine-components/OffsetConstraint" {
 }
 declare module "engine-components/ParticleSystemModules" {
     import * as THREE from "three";
+    import { Object3D, Vector3 } from "three";
+    import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
+    import { AnimationCurve } from "engine-components/AnimationCurve";
+    import { Vec3 } from "engine/engine_types";
+    type Color4 = {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    type ColorKey = {
+        time: number;
+        color: Color4;
+    };
+    type AlphaKey = {
+        time: number;
+        alpha: number;
+    };
+    export class Gradient {
+        alphaKeys: Array<AlphaKey>;
+        colorKeys: Array<ColorKey>;
+        get duration(): number;
+        evaluate(time: number, target: RGBAColor): RGBAColor;
+    }
+    export enum ParticleSystemCurveMode {
+        Constant = 0,
+        Curve = 1,
+        TwoCurves = 2,
+        TwoConstants = 3
+    }
+    export enum ParticleSystemGradientMode {
+        Color = 0,
+        Gradient = 1,
+        TwoColors = 2,
+        TwoGradients = 3,
+        RandomColor = 4
+    }
+    export enum ParticleSystemSimulationSpace {
+        Local = 0,
+        World = 1,
+        Custom = 2
+    }
+    export enum ParticleSystemShapeType {
+        Sphere = 0,
+        SphereShell = 1,
+        Hemisphere = 2,
+        HemisphereShell = 3,
+        Cone = 4,
+        Box = 5,
+        Mesh = 6,
+        ConeShell = 7,
+        ConeVolume = 8,
+        ConeVolumeShell = 9,
+        Circle = 10,
+        CircleEdge = 11,
+        SingleSidedEdge = 12,
+        MeshRenderer = 13,
+        SkinnedMeshRenderer = 14,
+        BoxShell = 15,
+        BoxEdge = 16,
+        Donut = 17,
+        Rectangle = 18,
+        Sprite = 19,
+        SpriteRenderer = 20
+    }
+    export class MinMaxCurve {
+        mode: ParticleSystemCurveMode;
+        constant: number;
+        constantMin: number;
+        constantMax: number;
+        curve?: AnimationCurve;
+        curveMin?: AnimationCurve;
+        curveMax?: AnimationCurve;
+        curveMultiplier?: number;
+        evaluate(t01: number, lerpFactor?: number): number;
+    }
+    export class MinMaxGradient {
+        mode: ParticleSystemGradientMode;
+        color: RGBAColor;
+        colorMin: RGBAColor;
+        colorMax: RGBAColor;
+        gradient: Gradient;
+        gradientMin: Gradient;
+        gradientMax: Gradient;
+        private _temp;
+        evaluate(t01: number, lerpFactor?: number): RGBAColor;
+    }
+    type ParticleSystemScalingMode = {
+        Hierarchy: number;
+        Local: number;
+        Shape: number;
+    };
     export class MainModule {
-        randomizeRotationDirection: number;
+        cullingMode: number;
         duration: number;
+        emitterVelocityMode: number;
+        flipRotation: number;
+        gravityModifier: MinMaxCurve;
+        gravityModifierMultiplier: number;
         loop: boolean;
+        maxParticles: number;
+        playOnAwake: boolean;
         prewarm: boolean;
-        startDelay: undefined;
+        ringBufferLoopRange: {
+            x: number;
+            y: number;
+        };
+        ringBufferMode: boolean;
+        scalingMode: ParticleSystemScalingMode;
+        simulationSpace: ParticleSystemSimulationSpace;
+        simulationSpeed: number;
+        startColor: MinMaxGradient;
+        startDelay: MinMaxCurve;
         startDelayMultiplier: number;
-        startLifetime: undefined;
+        startLifetime: MinMaxCurve;
         startLifetimeMultiplier: number;
-        startSpeed: undefined;
-        startSpeedMultiplier: number;
+        startRotation: MinMaxCurve;
+        startRotationMultiplier: number;
+        startRotation3D: boolean;
+        startRotationX: MinMaxCurve;
+        startRotationXMultiplier: number;
+        startRotationY: MinMaxCurve;
+        startRotationYMultiplier: number;
+        startRotationZ: MinMaxCurve;
+        startRotationZMultiplier: number;
+        startSize: MinMaxCurve;
         startSize3D: boolean;
-        startSize: undefined;
         startSizeMultiplier: number;
-        startSizeX: undefined;
+        startSizeX: MinMaxCurve;
         startSizeXMultiplier: number;
-        startSizeY: undefined;
+        startSizeY: MinMaxCurve;
         startSizeYMultiplier: number;
-        startSizeZ: undefined;
+        startSizeZ: MinMaxCurve;
         startSizeZMultiplier: number;
-        startRotation3D: boolean;
-        startRotation: undefined;
-        startRotationMultiplier: number;
-        startRotationX: undefined;
-        startRotationXMultiplier: number;
-        startRotationY: undefined;
-        startRotationYMultiplier: number;
-        startRotationZ: undefined;
-        startRotationZMultiplier: number;
-        flipRotation: number;
-        startColor: THREE.Color;
-        startColor1: THREE.Color | undefined;
-        gravityModifier: undefined;
-        gravityModifierMultiplier: number;
-        simulationSpace: number;
-        customSimulationSpace: null;
-        simulationSpeed: number;
-        useUnscaledTime: boolean;
-        scalingMode: number;
-        playOnAwake: boolean;
-        maxParticles: number;
-        emitterVelocityMode: number;
+        startSpeed: MinMaxCurve;
+        startSpeedMultiplier: number;
         stopAction: number;
-        ringBufferMode: number;
-        ringBufferLoopRange: THREE.Vector2;
-        cullingMode: number;
+        useUnscaledTime: boolean;
     }
     export class EmissionModule {
         burstCount: number;
         enabled: boolean;
-        rate: number;
-        rateMutliplier: number;
-        rateOverDistance: number;
-        rateOverDistanceMultiplier: number;
-        rateOverTime: number;
+        rateOverTime: MinMaxCurve;
         rateOverTimeMultiplier: number;
+        rateOverDistance: MinMaxCurve;
+        rateOverDistanceMultiplier: number;
+        currentParticles: number;
+        maxParticles: number;
+        private _time;
+        private _summed;
+        /** called by nebula */
+        init(): void;
+        /** called by nebula */
+        getValue(deltaTime: number): number;
+    }
+    export class ColorOverLifetimeModule {
+        enabled: boolean;
+        color: MinMaxGradient;
+    }
+    export class SizeOverLifetimeModule {
+        enabled: boolean;
+        separateAxes: boolean;
+        size: MinMaxCurve;
+        sizeMultiplier: number;
+        sizeX: MinMaxCurve;
+        sizeXMultiplier: number;
+        sizeY: MinMaxCurve;
+        sizeYMultiplier: number;
+        sizeZ: MinMaxCurve;
+        sizeZMultiplier: number;
+        private _time;
+        evaluate(t01: number, target: Vec3): Vec3;
     }
     export class ShapeModule {
         shapeType: ParticleSystemShapeType;
@@ -4133,68 +4338,85 @@ declare module "engine-components/ParticleSystemModules" {
         angle: number;
         arc: number;
         arcmode: number;
-        box: THREE.Vector3;
-        boxThickness: THREE.Vector3;
-        position: THREE.Vector3;
-        rotation: THREE.Vector3;
-        scale: THREE.Vector3;
+        boxThickness: Vector3;
+        position: Vector3;
+        rotation: Vector3;
+        scale: Vector3;
         radius: number;
+        radiusThickness: number;
         sphericalDirectionAmount: number;
+        private _space?;
+        private readonly _worldSpacePosition;
+        update(_context: Context, simulationSpace: ParticleSystemSimulationSpace, obj: Object3D): void;
+        /** nebula implementations: */
+        /** initializer implementation */
+        private _vector;
+        private _temp;
+        /** called by nebula on initialize */
+        get vector(): THREE.Vector3;
+        /** called by nebula */
+        getPosition(): void;
+        private _dir;
+        getDirection(position: any): Vec3;
     }
-    export enum ParticleSystemShapeType {
-        Sphere = 0,
-        SphereShell = 1,
-        Hemisphere = 2,
-        HemisphereShell = 3,
-        Cone = 4,
-        Box = 5,
-        Mesh = 6,
-        ConeVolume = 7,
-        Circle = 10,
-        SingleSidedEdge = 11,
-        MeshRenderer = 12,
-        SkinnedMeshRenderer = 13,
-        BoxShell = 14,
-        BoxEdge = 15,
-        Donut = 16,
-        Rectangle = 17,
-        Sprite = 18,
-        SpriteRenderer = 19
+    import { Context } from "engine/engine_setup";
+    export class NoiseModule {
+        damping: boolean;
+        enabled: boolean;
+        frequency: number;
+        octaveCount: number;
+        octaveMultiplier: number;
+        octaveScale: number;
+        positionAmount: MinMaxCurve;
+        quality: number;
+        remap: MinMaxCurve;
+        remapEnabled: boolean;
+        remapMultiplier: number;
+        remapX: MinMaxCurve;
+        remapXMultiplier: number;
+        remapY: MinMaxCurve;
+        remapYMultiplier: number;
+        remapZ: MinMaxCurve;
+        remapZMultiplier: number;
+        scrollSpeedMultiplier: number;
+        separateAxes: boolean;
+        strengthMultiplier: number;
+        strengthX: MinMaxCurve;
+        strengthXMultiplier: number;
+        strengthY: MinMaxCurve;
+        strengthYMultiplier: number;
+        strengthZ: MinMaxCurve;
+        strengthZMultiplier: number;
+        private _noise?;
+        private _time;
+        update(context: Context): void;
+        /** nebula implementations: */
+        private _temp;
+        applyNoise(index: number, pos: Vec3, vel: Vec3, deltaTime: number, age: number, life: number): void;
     }
 }
 declare module "engine-components/ParticleSystem" {
     import { Behaviour } from "engine-components/Component";
-    import * as THREE from "three";
-    import * as Modules from "engine-components/ParticleSystemModules";
+    import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule } from "engine-components/ParticleSystemModules";
+    import { SpriteMaterial } from "three";
     export class ParticleSystemRenderer extends Behaviour {
-        get mainTexture(): THREE.Texture | null;
-        getMesh(_index: number): THREE.Mesh | null;
-        private sharedMaterial?;
-        private mesh?;
-        awake(): void;
+        particleMaterial?: SpriteMaterial;
     }
     export class ParticleSystem extends Behaviour {
-        main: Modules.MainModule;
-        emission: Modules.EmissionModule;
-        shape: Modules.ShapeModule;
-        private renderer;
-        private geometry;
-        private material;
-        private particlesMesh;
-        private positions;
-        private positionsArray;
-        private particleStates;
-        private activeCount;
-        private shapeRotation;
-        private tempVec3;
-        private tempQuat;
+        colorOverLifetime: ColorOverLifetimeModule;
+        main: MainModule;
+        emission: EmissionModule;
+        sizeOverLifetime: SizeOverLifetimeModule;
+        shape: ShapeModule;
+        noise: NoiseModule;
+        renderer: ParticleSystemRenderer;
+        private _system;
+        private _emitter;
+        private _size;
         awake(): void;
         onEnable(): void;
-        emit(deltaTime: number): void;
-        private initializeParticle;
-        private updateOverLifetime;
-        private assignPosition;
-        private assignVelocity;
+        onDisable(): void;
+        onBeforeRender(): void;
     }
 }
 declare module "engine/engine_coroutine" {
@@ -5463,6 +5685,7 @@ declare module "engine-components/codegen/components" {
     export { Interactable } from "engine-components/Interactable";
     export { UsageMarker } from "engine-components/Interactable";
     export { FixedJoint } from "engine-components/Joints";
+    export { HingeJoint } from "engine-components/Joints";
     export { Light } from "engine-components/Light";
     export { LODModel } from "engine-components/LODGroup";
     export { LODGroup } from "engine-components/LODGroup";
@@ -5473,9 +5696,15 @@ declare module "engine-components/codegen/components" {
     export { OrbitControls } from "engine-components/OrbitControls";
     export { ParticleSystemRenderer } from "engine-components/ParticleSystem";
     export { ParticleSystem } from "engine-components/ParticleSystem";
+    export { Gradient } from "engine-components/ParticleSystemModules";
+    export { MinMaxCurve } from "engine-components/ParticleSystemModules";
+    export { MinMaxGradient } from "engine-components/ParticleSystemModules";
     export { MainModule } from "engine-components/ParticleSystemModules";
     export { EmissionModule } from "engine-components/ParticleSystemModules";
+    export { ColorOverLifetimeModule } from "engine-components/ParticleSystemModules";
+    export { SizeOverLifetimeModule } from "engine-components/ParticleSystemModules";
     export { ShapeModule } from "engine-components/ParticleSystemModules";
+    export { NoiseModule } from "engine-components/ParticleSystemModules";
     export { PlayerColor } from "engine-components/PlayerColor";
     export { ReflectionProbe } from "engine-components/ReflectionProbe";
     export { FieldWithDefault } from "engine-components/Renderer";