@needle-tools/engine 2.42.0-pre → 2.44.0-pre

package/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [2.44.0-pre] - 2022-11-11
+- Add: Particles limit velocity over time
+- Add: Particles rotation by speed
+- Add: ParticleSystem play, pause, stop and emit(count) methods
+- Add: ``WebXR.showRaycastLine`` exposed so it can be disabled from code
+- Fix: issues in applying some forces/values for different scaling and worldspace <> localspace scenarios
+- Change: raise input events in core method to also allow receiving WebAR mock touch events
+- Change: ``Animation.play()`` does not require argument anymore
+
+## [2.43.0-pre] - 2022-11-10
+- Add: particles emission over distance
+- Add: particles can enable trail (settings are not yet applied tho) 
+- Add: camera now useses culling mask settings
+- Add: particle VelocityOverLife
+- Add: particle basic texture sheet animation support
+- Change: ensure ``time.deltaTime`` is always > 0 and nevery exactly 0
+- Fix: progressbar handle progress event not reporting total file size
+- Fix: layer on camera did affect visibility
+- Fix: cloning animatorcontrollers in builds did fail because of legacy AnimatorAction name check
+- Fix: ``RGBAColor.lerpColors`` did produce wrong alpha value
+- Fix: custom shader ``_ZTest`` value is now applied as threejs depthTest function
+
 ## [2.42.0-pre] - 2022-11-09
 - add ``Graphics.copyTexture``
 - add ``Renderer.allowProgressiveLoad``

package/dist/needle-engine.d.ts

@@ -23,6 +23,7 @@ declare module "engine-components/js-extensions/RGBAColor" {
         clone(): this;
         copy(col: RGBAColor | Color): this;
         lerp(color: Color, alpha: number): this;
+        lerpColors(color1: Color, color2: Color, alpha: number): this;
         multiply(color: Color): this;
     }
 }
@@ -70,6 +71,7 @@ declare module "engine/engine_three_utils" {
     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 isAnimationAction(obj: object): boolean;
     export class Graphics {
         private static planeGeometry;
         private static renderer;
@@ -287,42 +289,6 @@ declare module "engine/engine_utils" {
     }
     export function isMobileDevice(): boolean;
 }
-declare module "engine/extensions/extension_resolver" {
-    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    export interface IExtensionReferenceResolver {
-        resolve(parser: GLTFParser, path: string): Promise<void> | null;
-    }
-}
-declare module "engine/engine_default_parameters" {
-    export const showGizmos: string | boolean;
-    export const debugExtension: string | boolean;
-}
-declare module "engine/extensions/extension_utils" {
-    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    export function resolveReferences(parser: GLTFParser, obj: any): Promise<void | void[]>;
-}
-declare module "engine/engine_typestore" {
-    class _TypeStore {
-        private _types;
-        add(key: any, type: any): void;
-        get(key: any): any;
-    }
-    export const $BuiltInTypeFlag: unique symbol;
-    export const TypeStore: _TypeStore;
-}
-declare module "engine/extensions/NEEDLE_persistent_assets" {
-    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { IExtensionReferenceResolver } from "engine/extensions/extension_resolver";
-    export const EXTENSION_NAME = "NEEDLE_persistent_assets";
-    export function isPersistentAsset(asset: any): boolean;
-    export class NEEDLE_persistent_assets implements GLTFLoaderPlugin, IExtensionReferenceResolver {
-        get name(): string;
-        private parser;
-        constructor(parser: GLTFParser);
-        afterRoot(_result: GLTF): Promise<void>;
-        resolve(parser: GLTFParser, path: string): Promise<void> | null | any;
-    }
-}
 declare module "engine/engine_networking_utils" {
     export function isLocalNetwork(hostname?: string): boolean;
     export function isHostedOnGlitch(): boolean;
@@ -363,6 +329,42 @@ declare module "engine/debug/debug" {
     export function showBalloonMessage(text: string, logType?: LogType): void;
     export function showBalloonWarning(text: string): void;
 }
+declare module "engine/extensions/extension_resolver" {
+    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    export interface IExtensionReferenceResolver {
+        resolve(parser: GLTFParser, path: string): Promise<void> | null;
+    }
+}
+declare module "engine/engine_default_parameters" {
+    export const showGizmos: string | boolean;
+    export const debugExtension: string | boolean;
+}
+declare module "engine/extensions/extension_utils" {
+    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    export function resolveReferences(parser: GLTFParser, obj: any): Promise<void | void[]>;
+}
+declare module "engine/engine_typestore" {
+    class _TypeStore {
+        private _types;
+        add(key: any, type: any): void;
+        get(key: any): any;
+    }
+    export const $BuiltInTypeFlag: unique symbol;
+    export const TypeStore: _TypeStore;
+}
+declare module "engine/extensions/NEEDLE_persistent_assets" {
+    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    import { IExtensionReferenceResolver } from "engine/extensions/extension_resolver";
+    export const EXTENSION_NAME = "NEEDLE_persistent_assets";
+    export function isPersistentAsset(asset: any): boolean;
+    export class NEEDLE_persistent_assets implements GLTFLoaderPlugin, IExtensionReferenceResolver {
+        get name(): string;
+        private parser;
+        constructor(parser: GLTFParser);
+        afterRoot(_result: GLTF): Promise<void>;
+        resolve(parser: GLTFParser, path: string): Promise<void> | null | any;
+    }
+}
 declare module "engine/engine_serialization_core" {
     import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
     import { Object3D } from "three";
@@ -1904,6 +1906,23 @@ declare module "engine/engine_setup" {
         private executeCoroutines;
     }
 }
+declare module "engine/engine_util_decorator" {
+    import { IComponent } from "engine/engine_types";
+    type setter = (v: any) => void;
+    type getter = () => any;
+    /** create accessor callbacks for a field */
+    export const validate: (set?: setter, get?: getter) => (target: IComponent | any, propertyKey: string, descriptor?: undefined) => void;
+}
+declare module "engine/api" {
+    export { InstancingUtil } from "engine/engine_instancing";
+    export * from "engine/engine_gameobject";
+    export * from "engine/engine_components";
+    export { AssetReference } from "engine/engine_addressables";
+    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/engine_element_loading" {
     import { LoadingProgressArgs } from "engine/engine_setup";
     export class LoadingElementOptions {
@@ -2178,6 +2197,8 @@ declare module "engine-components/Animation" {
         randomStartTime: boolean;
         minMaxSpeed?: Vec2;
         minMaxOffsetNormalized?: Vec2;
+        loop: boolean;
+        clampWhenFinished: boolean;
         private _tempAnimationClipBeforeGameObjectExisted;
         get clip(): AnimationClip | null;
         set clip(val: AnimationClip | null);
@@ -2203,7 +2224,7 @@ declare module "engine-components/Animation" {
         update(): void;
         getAction(name: string): THREE.AnimationAction | undefined | null;
         get isPlaying(): boolean;
-        play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void;
+        play(clipOrNumber: AnimationClip | number | string | undefined, options?: PlayOptions): Promise<AnimationAction> | void;
         internalOnPlay(action: AnimationAction, options?: PlayOptions): Promise<AnimationAction>;
         private tryFindHandle;
         private _didInit;
@@ -2470,23 +2491,6 @@ declare module "engine/engine_element" {
         private onBeforeBeginLoading;
     }
 }
-declare module "engine/engine_util_decorator" {
-    import { IComponent } from "engine/engine_types";
-    type setter = (v: any) => void;
-    type getter = () => any;
-    /** create accessor callbacks for a field */
-    export const validate: (set?: setter, get?: getter) => (target: IComponent | any, propertyKey: string, descriptor?: undefined) => void;
-}
-declare module "engine/api" {
-    export { InstancingUtil } from "engine/engine_instancing";
-    export * from "engine/engine_gameobject";
-    export * from "engine/engine_components";
-    export { AssetReference } from "engine/engine_addressables";
-    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";
     export class AlignmentConstraint extends Behaviour {
@@ -2602,6 +2606,9 @@ declare module "engine-components/Camera" {
         orthographic: boolean;
         orthographicSize: number;
         ARBackgroundAlpha: number;
+        set cullingMask(val: number);
+        get cullingMask(): number;
+        private _cullingMask;
         private _nearClipPlane;
         private _farClipPlane;
         get backgroundColor(): RGBAColor | null;
@@ -3593,6 +3600,7 @@ declare module "engine-components/WebXRController" {
         grabbed: AttachedObject | null;
         input: XRInputSource | null;
         type: ControllerType;
+        showRaycastLine: boolean;
         get isUsingHands(): boolean;
         get wrist(): Object3D | null;
         private _wristQuaternion;
@@ -4169,10 +4177,11 @@ declare module "engine-components/OffsetConstraint" {
 }
 declare module "engine-components/ParticleSystemModules" {
     import * as THREE from "three";
-    import { Object3D, Vector3 } from "three";
+    import { Object3D, Quaternion, Vector3 } from "three";
     import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
     import { AnimationCurve } from "engine-components/AnimationCurve";
-    import { Vec3 } from "engine/engine_types";
+    import { Vec2, Vec3 } from "engine/engine_types";
+    import { EmitterShape, Particle, ShapeJSON } from "three.quarks";
     type Color4 = {
         r: number;
         g: number;
@@ -4193,6 +4202,10 @@ declare module "engine-components/ParticleSystemModules" {
         get time(): number;
         get duration(): number;
         readonly main: MainModule;
+        get container(): Object3D;
+        get worldQuaternion(): Quaternion;
+        get worldQuaternionInverted(): Quaternion;
+        get worldScale(): Vector3;
     }
     export enum ParticleSystemRenderMode {
         Billboard = 0,
@@ -4351,12 +4364,8 @@ declare module "engine-components/ParticleSystemModules" {
         rateOverDistanceMultiplier: number;
         /** set from system */
         system: IParticleSystem;
-        get time(): number;
-        private _summed;
-        /** called by nebula */
-        init(): void;
-        /** called by nebula */
-        getValue(deltaTime: number): number;
+        reset(): void;
+        getBurst(): number;
     }
     export class ColorOverLifetimeModule {
         enabled: boolean;
@@ -4367,16 +4376,21 @@ declare module "engine-components/ParticleSystemModules" {
         separateAxes: boolean;
         size: MinMaxCurve;
         sizeMultiplier: number;
-        sizeX: MinMaxCurve;
-        sizeXMultiplier: number;
-        sizeY: MinMaxCurve;
-        sizeYMultiplier: number;
-        sizeZ: MinMaxCurve;
-        sizeZMultiplier: number;
+        x: MinMaxCurve;
+        xMultiplier: number;
+        y: MinMaxCurve;
+        yMultiplier: number;
+        z: MinMaxCurve;
+        zMultiplier: number;
         private _time;
-        evaluate(t01: number, target: Vec3): Vec3;
+        private _temp;
+        evaluate(t01: number, target?: Vec3): Vec3;
     }
-    export class ShapeModule {
+    export class ShapeModule implements EmitterShape {
+        get type(): string;
+        initialize(particle: Particle): void;
+        toJSON(): ShapeJSON;
+        clone(): EmitterShape;
         shapeType: ParticleSystemShapeType;
         enabled: boolean;
         alignToDirection: boolean;
@@ -4390,16 +4404,17 @@ declare module "engine-components/ParticleSystemModules" {
         radius: number;
         radiusThickness: number;
         sphericalDirectionAmount: number;
+        private system;
         private _space?;
-        private readonly _worldSpacePosition;
-        update(_context: Context, simulationSpace: ParticleSystemSimulationSpace, obj: Object3D): void;
+        private readonly _worldSpaceMatrix;
+        private readonly _worldSpaceMatrixInverse;
+        update(system: IParticleSystem, _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): Vector3;
@@ -4437,38 +4452,160 @@ declare module "engine-components/ParticleSystemModules" {
         update(context: Context): void;
         /** nebula implementations: */
         private _temp;
-        applyNoise(index: number, pos: Vec3, vel: Vec3, deltaTime: number, age: number, life: number): void;
+        apply(_index: number, pos: Vec3, vel: Vec3, _deltaTime: number, age: number, life: number): void;
+    }
+    export class TrailModule {
+        enabled: boolean;
+    }
+    export class VelocityOverLifetimeModule {
+        enabled: boolean;
+        space: ParticleSystemSimulationSpace;
+        speedModifier: MinMaxCurve;
+        speedModifierMultiplier: number;
+        x: MinMaxCurve;
+        xMultiplier: number;
+        y: MinMaxCurve;
+        yMultiplier: number;
+        z: MinMaxCurve;
+        zMultiplier: number;
+        private _system?;
+        update(system: IParticleSystem): void;
+        private _temp;
+        apply(_index: number, _pos: Vec3, vel: Vec3, _dt: number, age: number, life: number): void;
+    }
+    enum ParticleSystemAnimationTimeMode {
+        Lifetime = 0,
+        Speed = 1,
+        FPS = 2
+    }
+    enum ParticleSystemAnimationRowMode {
+        Custom = 0,
+        Random = 1,
+        MeshIndex = 2
+    }
+    enum ParticleSystemAnimationType {
+        WholeSheet = 0,
+        SingleRow = 1
+    }
+    export class TextureSheetAnimationModule {
+        animation: ParticleSystemAnimationType;
+        enabled: boolean;
+        cycleCount: number;
+        frameOverTime: MinMaxCurve;
+        frameOverTimeMultiplier: number;
+        numTilesX: number;
+        numTilesY: number;
+        startFrame: MinMaxCurve;
+        startFrameMultiplier: number;
+        rowMode: ParticleSystemAnimationRowMode;
+        rowIndex: number;
+        spriteCount: number;
+        timeMode: ParticleSystemAnimationTimeMode;
+        private sampleOnceAtStart;
+        getStartIndex(): number;
+        evaluate(t01: number): number | undefined;
+        private getIndex;
+    }
+    export class RotationOverLifetimeModule {
+        enabled: boolean;
+        separateAxes: boolean;
+        x: MinMaxCurve;
+        xMultiplier: number;
+        y: MinMaxCurve;
+        yMultiplier: number;
+        z: MinMaxCurve;
+        zMultiplier: number;
+        evaluate(t01: number): number;
+    }
+    export class RotationBySpeedModule {
+        enabled: boolean;
+        range: Vec2;
+        separateAxes: boolean;
+        x: MinMaxCurve;
+        xMultiplier: number;
+        y: MinMaxCurve;
+        yMultiplier: number;
+        z: MinMaxCurve;
+        zMultiplier: number;
+        evaluate(_t01: number, speed: number): number;
+    }
+    export class LimitVelocityOverLifetimeModule {
+        enabled: boolean;
+        dampen: number;
+        drag: MinMaxCurve;
+        dragMultiplier: number;
+        limit: MinMaxCurve;
+        limitMultiplier: number;
+        separateAxes: boolean;
+        limitX: MinMaxCurve;
+        limitXMultiplier: number;
+        limitY: MinMaxCurve;
+        limitYMultiplier: number;
+        limitZ: MinMaxCurve;
+        limitZMultiplier: number;
+        multiplyDragByParticleSize: boolean;
+        multiplyDragByParticleVelocity: boolean;
+        space: ParticleSystemSimulationSpace;
+        private _temp;
+        private _temp2;
+        apply(_position: Vec3, baseVelocity: Vector3, currentVelocity: Vector3, _size: number, t01: number, _dt: number, _scale: number): void;
     }
 }
 declare module "engine-components/ParticleSystem" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
-    import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, IParticleSystem, ParticleSystemRenderMode } from "engine-components/ParticleSystemModules";
-    import { Mesh, SpriteMaterial } from "three";
+    import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, IParticleSystem, ParticleSystemRenderMode, TrailModule, VelocityOverLifetimeModule, TextureSheetAnimationModule, RotationOverLifetimeModule, LimitVelocityOverLifetimeModule, RotationBySpeedModule } from "engine-components/ParticleSystemModules";
+    import { Mesh, Object3D, Quaternion, SpriteMaterial, Vector3 } from "three";
     export class ParticleSystemRenderer extends Behaviour {
         renderMode?: ParticleSystemRenderMode;
         particleMaterial?: SpriteMaterial;
         particleMesh?: Mesh | string;
+        get transparent(): boolean;
         getMesh(): THREE.Mesh<THREE.BufferGeometry, THREE.SpriteMaterial>;
     }
     export class ParticleSystem extends Behaviour implements IParticleSystem {
+        play(includeChildren?: boolean): void;
+        pause(): void;
+        stop(): void;
+        private _state?;
+        emit(count: number): void;
         readonly colorOverLifetime: ColorOverLifetimeModule;
         readonly main: MainModule;
         readonly emission: EmissionModule;
         readonly sizeOverLifetime: SizeOverLifetimeModule;
         readonly shape: ShapeModule;
         readonly noise: NoiseModule;
+        readonly trails: TrailModule;
+        readonly velocityOverLifetime: VelocityOverLifetimeModule;
+        readonly limitVelocityOverLifetime: LimitVelocityOverLifetimeModule;
+        readonly textureSheetAnimation: TextureSheetAnimationModule;
+        readonly rotationOverLifetime: RotationOverLifetimeModule;
+        readonly rotationBySpeed: RotationBySpeedModule;
         get renderer(): ParticleSystemRenderer;
-        get currentParticles(): any;
+        get isPlaying(): any;
+        get currentParticles(): number;
         get maxParticles(): number;
         get time(): number;
         get duration(): number;
+        get deltaTime(): number;
+        get scale(): number;
+        get cameraScale(): number;
+        private _cameraScale;
+        get container(): Object3D;
+        get worldspace(): boolean;
+        private __worldQuaternion;
+        get worldQuaternion(): Quaternion;
+        private _worldQuaternionInverted;
+        get worldQuaternionInverted(): Quaternion;
+        private _worldScale;
+        get worldScale(): Vector3;
         private _renderer;
-        private _system;
-        private _emitter;
-        private _size;
-        private _container?;
+        private _batchSystem?;
+        private _particleSystem?;
+        private _interface;
+        private _container;
         private _time;
+        private _isPlaying;
         /** called from deserialization */
         private set bursts(value);
         private _bursts?;
@@ -5765,6 +5902,12 @@ declare module "engine-components/codegen/components" {
     export { SizeOverLifetimeModule } from "engine-components/ParticleSystemModules";
     export { ShapeModule } from "engine-components/ParticleSystemModules";
     export { NoiseModule } from "engine-components/ParticleSystemModules";
+    export { TrailModule } from "engine-components/ParticleSystemModules";
+    export { VelocityOverLifetimeModule } from "engine-components/ParticleSystemModules";
+    export { TextureSheetAnimationModule } from "engine-components/ParticleSystemModules";
+    export { RotationOverLifetimeModule } from "engine-components/ParticleSystemModules";
+    export { RotationBySpeedModule } from "engine-components/ParticleSystemModules";
+    export { LimitVelocityOverLifetimeModule } from "engine-components/ParticleSystemModules";
     export { PlayerColor } from "engine-components/PlayerColor";
     export { ReflectionProbe } from "engine-components/ReflectionProbe";
     export { FieldWithDefault } from "engine-components/Renderer";