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

package/CHANGELOG.md

@@ -4,6 +4,17 @@ 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.42.0-pre] - 2022-11-09
+- add ``Graphics.copyTexture``
+- add ``Renderer.allowProgressiveLoad``
+- add ``Gizmos.DrawBox`` and ``DrawBox3``
+- add particles burst emission
+- add particles color interpolation between two gradients
+- fix: reflection probe material caching for when material is being changed at certain times outside of animation loop and cache applied wrong material
+- fix: AnimationCurve evaluation when time and keyframe are both exactly 0
+- change: reflection probe now requires anchor override
+- change: bump threejs dependency 
+
 ## [2.41.0-pre] - 2022-11-07
 - Add: start adding particle systems support again
 - Change: update dependency version to needle gltf-transform-extensions package

package/dist/needle-engine.d.ts

@@ -53,7 +53,7 @@ declare module "engine/engine_physics.types" {
 }
 declare module "engine/engine_three_utils" {
     import * as THREE from "three";
-    import { Vector3 } from "three";
+    import { Vector3, Texture, ShaderMaterial } 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;
@@ -70,7 +70,22 @@ 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 class Graphics {
+        private static planeGeometry;
+        private static renderer;
+        private static perspectiveCam;
+        private static scene;
+        private static readonly vertex;
+        private static readonly fragment;
+        private static readonly blipMaterial;
+        static createBlitMaterial(fragment: string): ShaderMaterial;
+        private static readonly mesh;
+        static copyTexture(texture: Texture, blitMaterial?: ShaderMaterial): THREE.Texture;
+        static textureToCanvas(texture: Texture, force: boolean): HTMLCanvasElement | null;
+    }
+    /**@obsolete use Graphics.copyTexture */
     export function copyTexture(texture: THREE.Texture): THREE.Texture;
+    /**@obsolete use Graphics.textureToCanvas */
     export function textureToCanvas(texture: THREE.Texture, force?: boolean): HTMLCanvasElement | null;
 }
 declare module "engine/engine_types" {
@@ -194,6 +209,12 @@ declare module "engine/engine_types" {
         y: number;
         z: number;
     };
+    export type Vec4 = {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
     export class ContactPoint {
         private readonly _point;
         private readonly _normal;
@@ -768,30 +789,16 @@ declare module "engine/engine_gameobject" {
 }
 declare module "engine/engine_gizmos" {
     import * as THREE from 'three';
-    import { ColorRepresentation } from 'three';
-    import { Vec3 } from "engine/engine_types";
+    import { ColorRepresentation, Box3 } from 'three';
+    import { Vec3, Vec4 } 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;
+        static DrawDirection(pt: Vec3, direction: Vec3 | Vec4, color?: ColorRepresentation, duration?: number, depthTest?: boolean, lengthFactor?: number): void;
+        static DrawLine(pt0: Vec3, pt1: Vec3, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+        static DrawWireSphere(center: Vec3, radius: number, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+        static DrawSphere(center: Vec3, radius: number, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+        static DrawBox(center: Vec3, size: Vec3, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
+        static DrawBox3(box: Box3, color?: ColorRepresentation, duration?: number, depthTest?: boolean): void;
     }
     export function CreateWireCube(col?: THREE.ColorRepresentation | null): THREE.LineSegments;
 }
@@ -1824,6 +1831,9 @@ declare module "engine/engine_setup" {
         get isInAR(): boolean;
         get xrSession(): THREE.XRSession | null;
         get arOverlayElement(): HTMLElement;
+        /** Current event of the update cycle */
+        get currentFrameEvent(): FrameEvent;
+        private _currentFrameEvent;
         scene: THREE.Scene;
         renderer: THREE.WebGLRenderer;
         composer: EffectComposer | null;
@@ -3471,6 +3481,7 @@ declare module "engine-components/Renderer" {
         get lightmap(): Texture | null;
         set lightmap(tex: Texture | null | undefined);
         get hasLightmap(): boolean;
+        allowProgressiveLoading: boolean;
         awake(): void;
         private _isInstancingEnabled;
         private handles;
@@ -4176,6 +4187,17 @@ declare module "engine-components/ParticleSystemModules" {
         time: number;
         alpha: number;
     };
+    export interface IParticleSystem {
+        get currentParticles(): number;
+        get maxParticles(): number;
+        get time(): number;
+        get duration(): number;
+        readonly main: MainModule;
+    }
+    export enum ParticleSystemRenderMode {
+        Billboard = 0,
+        Mesh = 4
+    }
     export class Gradient {
         alphaKeys: Array<AlphaKey>;
         colorKeys: Array<ColorKey>;
@@ -4242,7 +4264,8 @@ declare module "engine-components/ParticleSystemModules" {
         gradient: Gradient;
         gradientMin: Gradient;
         gradientMax: Gradient;
-        private _temp;
+        private static _temp;
+        private static _temp2;
         evaluate(t01: number, lerpFactor?: number): RGBAColor;
     }
     type ParticleSystemScalingMode = {
@@ -4297,16 +4320,38 @@ declare module "engine-components/ParticleSystemModules" {
         stopAction: number;
         useUnscaledTime: boolean;
     }
+    export class ParticleBurst {
+        cycleCount: number;
+        maxCount: number;
+        minCount: number;
+        probability: number;
+        repeatInterval: number;
+        time: number;
+        count: {
+            constant: number;
+            constantMax: number;
+            constantMin: number;
+            curve?: AnimationCurve;
+            curveMax?: AnimationCurve;
+            curveMin?: AnimationCurve;
+            curveMultiplier?: number;
+            mode: ParticleSystemCurveMode;
+        };
+        private _performed;
+        reset(): void;
+        run(time: number): number;
+    }
     export class EmissionModule {
-        burstCount: number;
         enabled: boolean;
+        get burstCount(): number;
+        bursts: ParticleBurst[];
         rateOverTime: MinMaxCurve;
         rateOverTimeMultiplier: number;
         rateOverDistance: MinMaxCurve;
         rateOverDistanceMultiplier: number;
-        currentParticles: number;
-        maxParticles: number;
-        private _time;
+        /** set from system */
+        system: IParticleSystem;
+        get time(): number;
         private _summed;
         /** called by nebula */
         init(): void;
@@ -4357,7 +4402,7 @@ declare module "engine-components/ParticleSystemModules" {
         /** called by nebula */
         getPosition(): void;
         private _dir;
-        getDirection(position: any): Vec3;
+        getDirection(position: any): Vector3;
     }
     import { Context } from "engine/engine_setup";
     export class NoiseModule {
@@ -4397,22 +4442,36 @@ declare module "engine-components/ParticleSystemModules" {
 }
 declare module "engine-components/ParticleSystem" {
     import { Behaviour } from "engine-components/Component";
-    import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule } from "engine-components/ParticleSystemModules";
-    import { SpriteMaterial } from "three";
+    import * as THREE from "three";
+    import { MainModule, EmissionModule, ShapeModule, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, IParticleSystem, ParticleSystemRenderMode } from "engine-components/ParticleSystemModules";
+    import { Mesh, SpriteMaterial } from "three";
     export class ParticleSystemRenderer extends Behaviour {
+        renderMode?: ParticleSystemRenderMode;
         particleMaterial?: SpriteMaterial;
-    }
-    export class ParticleSystem extends Behaviour {
-        colorOverLifetime: ColorOverLifetimeModule;
-        main: MainModule;
-        emission: EmissionModule;
-        sizeOverLifetime: SizeOverLifetimeModule;
-        shape: ShapeModule;
-        noise: NoiseModule;
-        renderer: ParticleSystemRenderer;
+        particleMesh?: Mesh | string;
+        getMesh(): THREE.Mesh<THREE.BufferGeometry, THREE.SpriteMaterial>;
+    }
+    export class ParticleSystem extends Behaviour implements IParticleSystem {
+        readonly colorOverLifetime: ColorOverLifetimeModule;
+        readonly main: MainModule;
+        readonly emission: EmissionModule;
+        readonly sizeOverLifetime: SizeOverLifetimeModule;
+        readonly shape: ShapeModule;
+        readonly noise: NoiseModule;
+        get renderer(): ParticleSystemRenderer;
+        get currentParticles(): any;
+        get maxParticles(): number;
+        get time(): number;
+        get duration(): number;
+        private _renderer;
         private _system;
         private _emitter;
         private _size;
+        private _container?;
+        private _time;
+        /** called from deserialization */
+        private set bursts(value);
+        private _bursts?;
         awake(): void;
         onEnable(): void;
         onDisable(): void;
@@ -5700,6 +5759,7 @@ declare module "engine-components/codegen/components" {
     export { MinMaxCurve } from "engine-components/ParticleSystemModules";
     export { MinMaxGradient } from "engine-components/ParticleSystemModules";
     export { MainModule } from "engine-components/ParticleSystemModules";
+    export { ParticleBurst } from "engine-components/ParticleSystemModules";
     export { EmissionModule } from "engine-components/ParticleSystemModules";
     export { ColorOverLifetimeModule } from "engine-components/ParticleSystemModules";
     export { SizeOverLifetimeModule } from "engine-components/ParticleSystemModules";