@needle-tools/engine 2.56.2-pre → 2.58.0-pre

package/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.58.0-pre] - 2023-01-09
+- Add: EventSystem input events (e.g. IPointerClick) are now invoked for all buttons (e.g. right click)
+- Add: Hot reload for components
+
+## [2.57.0-pre] - 2023-01-07
+- Remove: Meshline dependency
+- Fix: Testrunner Rigidbody import error
+
 ## [2.56.2-pre] - 2023-01-06
 - Change: Component.addEventListener argument can now derive from Event
 

package/dist/needle-engine.d.ts

@@ -1935,6 +1935,7 @@ declare module "engine-components/CameraUtils" {
     export function createCameraWithOrbitControl(scene: Scene, source: SourceIdentifier): ICamera;
 }
 declare module "engine/engine_setup" {
+    import { Camera } from 'three';
     import * as THREE from 'three';
     import { Input } from "engine/engine_input";
     import { Physics } from "engine/engine_physics";
@@ -2066,8 +2067,8 @@ declare module "engine/engine_setup" {
         private _stats;
         constructor(args: ContextArgs | undefined);
         private _disposeCallbacks;
-        private updateSize;
-        updateAspect(camera: THREE.PerspectiveCamera): void;
+        updateSize(): void;
+        updateAspect(camera: THREE.PerspectiveCamera, width?: number, height?: number): void;
         onCreate(buildScene?: (context: Context, loadingOptions?: LoadingOptions) => Promise<void>, opts?: LoadingOptions): Promise<void> | null;
         onDestroy(): void;
         registerCoroutineUpdate(script: IComponent, coroutine: Generator, evt: FrameEvent): Generator;
@@ -2093,6 +2094,7 @@ declare module "engine/engine_setup" {
         get isVisibleToUser(): boolean;
         private internalOnCreate;
         private render;
+        renderNow(camera?: Camera): boolean;
         /** returns true if we should return out of the frame loop */
         private _wasPaused;
         private onHandlePaused;
@@ -2143,59 +2145,6 @@ declare module "engine/engine_util_decorator" {
      */
     export const prefix: <T>(type: Constructor<T>) => (target: IComponent | any, propertyKey: string, _PropertyDescriptor: PropertyDescriptor) => void;
 }
-declare module "engine/api" {
-    export { TypeStore } from "engine/engine_typestore";
-    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 {
-        className?: string;
-        additionalClasses?: string[];
-    }
-    export interface ILoadingViewHandler {
-        onLoadingBegin(message?: string): any;
-        onLoadingUpdate(progress: LoadingProgressArgs, message?: string): any;
-        onLoadingFinished(message?: string): any;
-    }
-    export function calculateProgress01(progress: LoadingProgressArgs): number;
-    export class EngineLoadingView implements ILoadingViewHandler {
-        static LoadingContainerClassName: string;
-        loadingProgress: number;
-        private container;
-        private _progress;
-        private _allowCustomLoadingElement;
-        private _loadingElement?;
-        private _loadingTextContainer;
-        private _loadingBar;
-        private _messageContainer;
-        private _loadingElementOptions?;
-        constructor(container: HTMLElement, opts?: LoadingElementOptions);
-        onLoadingBegin(message?: string): void;
-        onLoadingUpdate(progress: LoadingProgressArgs | ProgressEvent | number, message?: string): void;
-        onLoadingFinished(message?: string): void;
-        setMessage(message: string): void;
-        private _progressLoop;
-        private smoothProgressLoop;
-        private updateDisplay;
-        private createLoadingElement;
-    }
-}
-declare module "engine/engine_loaders" {
-    import { Context } from "engine/engine_setup";
-    import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
-    export function setDracoDecoderPath(path: string | undefined): void;
-    export function setDracoDecoderType(type: string | undefined): void;
-    export function setKtx2TranscoderPath(path: string): void;
-    export function addDracoAndKTX2Loaders(loader: GLTFLoader, context: Context): void;
-}
 declare module "engine/extensions/NEEDLE_animator_controller_model" {
     import { Animator } from "engine-components/Animator";
     import { AnimationAction, AnimationClip, Object3D } from "three";
@@ -2454,6 +2403,14 @@ declare module "engine-components/Animation" {
         init(): void;
     }
 }
+declare module "engine/engine_loaders" {
+    import { Context } from "engine/engine_setup";
+    import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+    export function setDracoDecoderPath(path: string | undefined): void;
+    export function setDracoDecoderType(type: string | undefined): void;
+    export function setKtx2TranscoderPath(path: string): void;
+    export function addDracoAndKTX2Loaders(loader: GLTFLoader, context: Context): void;
+}
 declare module "engine/extensions/NEEDLE_techniques_webgl" {
     import { GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
     import * as THREE from 'three';
@@ -2715,6 +2672,7 @@ declare module "engine/engine_scenetools" {
     export type GltfLoadEventCallback = (event: GltfLoadEvent) => void;
     export function addGltfLoadEventListener(type: GltfLoadEventType, listener: GltfLoadEventCallback): void;
     export function removeGltfLoadEventListener(type: GltfLoadEventType, listener: GltfLoadEventCallback): void;
+    export function createGLTFLoader(url: string, context: Context): GLTFLoader;
     export function parseSync(context: Context, data: any, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
     export function loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator?: boolean, prog?: (ProgressEvent: any) => void): Promise<GLTF | undefined>;
     export function findAnimationsLate(_context: Context, gltf: any, callbackarray: any, allowAddingAnimator?: boolean): void;
@@ -2723,6 +2681,52 @@ declare module "engine/engine_scenetools" {
     export function tryFindObject(globalObjectIdentifier: any, obj: any, recursive?: boolean): any;
     export function tryFindScript(globalObjectIdentifier: any, list?: null): import("engine/engine_types").IComponent | null;
 }
+declare module "engine/api" {
+    export { TypeStore } from "engine/engine_typestore";
+    export { InstancingUtil } from "engine/engine_instancing";
+    export * from "engine/engine_gameobject";
+    export * from "engine/engine_components";
+    export { AssetReference } from "engine/engine_addressables";
+    export { Context, FrameEvent } from "engine/engine_setup";
+    export * from "engine/debug/debug";
+    export { validate } from "engine/engine_util_decorator";
+    export { Gizmos } from "engine/engine_gizmos";
+    export * from "engine/engine_scenetools";
+}
+declare module "engine/engine_element_loading" {
+    import { LoadingProgressArgs } from "engine/engine_setup";
+    export class LoadingElementOptions {
+        className?: string;
+        additionalClasses?: string[];
+    }
+    export interface ILoadingViewHandler {
+        onLoadingBegin(message?: string): any;
+        onLoadingUpdate(progress: LoadingProgressArgs, message?: string): any;
+        onLoadingFinished(message?: string): any;
+    }
+    export function calculateProgress01(progress: LoadingProgressArgs): number;
+    export class EngineLoadingView implements ILoadingViewHandler {
+        static LoadingContainerClassName: string;
+        loadingProgress: number;
+        private container;
+        private _progress;
+        private _allowCustomLoadingElement;
+        private _loadingElement?;
+        private _loadingTextContainer;
+        private _loadingBar;
+        private _messageContainer;
+        private _loadingElementOptions?;
+        constructor(container: HTMLElement, opts?: LoadingElementOptions);
+        onLoadingBegin(message?: string): void;
+        onLoadingUpdate(progress: LoadingProgressArgs | ProgressEvent | number, message?: string): void;
+        onLoadingFinished(message?: string): void;
+        setMessage(message: string): void;
+        private _progressLoop;
+        private smoothProgressLoop;
+        private updateDisplay;
+        private createLoadingElement;
+    }
+}
 declare module "engine/engine_element" {
     import { Context } from "engine/engine_setup";
     import { INeedleEngineComponent } from "engine/engine_types";
@@ -3649,6 +3653,7 @@ declare module "engine-components/avatar/Avatar_Brain_LookAt" {
     }
 }
 declare module "engine-components/ui/PointerEvents" {
+    import { Input } from "engine/engine_input";
     export interface IInputEventArgs {
         get used(): boolean;
         Use(): void;
@@ -3658,8 +3663,9 @@ declare module "engine-components/ui/PointerEvents" {
         used: boolean;
         Use(): void;
         StopPropagation(): void;
-        inputSource: any;
+        inputSource: Input | any;
         object: THREE.Object3D;
+        pointerId: number | undefined;
         isDown: boolean | undefined;
         isUp: boolean | undefined;
         isPressed: boolean | undefined;
@@ -3861,9 +3867,9 @@ declare module "engine-components/ui/EventSystem" {
         private _selectStartFn?;
         private _selectEndFn?;
         private _selectUpdateFn?;
+        private _onBeforeUpdateFn?;
         onEnable(): void;
         onDisable(): void;
-        onPointerDown(): void;
         private lastPointerEvent;
         private objectsHoveredThisFrame;
         private objectsHoveredLastFrame;
@@ -5332,6 +5338,28 @@ declare module "engine-components/FlyControls" {
         update(): void;
     }
 }
+declare module "engine-components/Fog" {
+    import { Behaviour } from "engine-components/Component";
+    import { Color, Fog as Fog3 } from "three";
+    export enum FogMode {
+        Linear = 1,
+        Exponential = 2,
+        ExponentialSquared = 3
+    }
+    export class Fog extends Behaviour {
+        get fog(): Fog3;
+        get mode(): FogMode;
+        set near(value: number);
+        get near(): number;
+        set far(value: number);
+        get far(): number;
+        set color(value: Color);
+        get color(): Color;
+        private _fog?;
+        onEnable(): void;
+        onDisable(): void;
+    }
+}
 declare module "include/three/EXT_mesh_gpu_instancing_exporter" {
     export default class GLTFMeshGPUInstancingExtension {
         constructor(writer: any);
@@ -6412,6 +6440,7 @@ declare module "engine-components/codegen/components" {
     export { FieldWithDefault } from "engine-components/Renderer";
     export { FixedJoint } from "engine-components/Joints";
     export { FlyControls } from "engine-components/FlyControls";
+    export { Fog } from "engine-components/Fog";
     export { GltfExport } from "engine-components/export/gltf/GltfExport";
     export { GltfExportBox } from "engine-components/export/gltf/GltfExport";
     export { Gradient } from "engine-components/ParticleSystemModules";
@@ -6534,41 +6563,26 @@ declare module "needle-engine" {
     export * from "engine-components/codegen/components";
     export * from "engine-components/js-extensions/Object3D";
 }
+declare module "engine/engine_hot_reload" {
+    export function register(instance: object): void;
+    export function unregister(instance: object): void;
+    export function applyChanges(newModule: any): boolean;
+}
 declare module "engine/engine" {
-    import * as engine_setup from "engine/engine_setup";
-    import * as engine_scenetools from "engine/engine_scenetools";
+    import "engine/engine_hot_reload";
     import "engine/tests/test_utils";
-    import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
-    const engine: {
-        RGBAColor: typeof RGBAColor;
-        addGltfLoadEventListener(type: engine_scenetools.GltfLoadEventType, listener: engine_scenetools.GltfLoadEventCallback): void;
-        removeGltfLoadEventListener(type: engine_scenetools.GltfLoadEventType, listener: engine_scenetools.GltfLoadEventCallback): void;
-        parseSync(context: engine_setup.Context, data: any, path: string, seed: number | import("engine/engine_types").UIDProvider | null): Promise<import("three/examples/jsm/loaders/GLTFLoader").GLTF | undefined>;
-        loadSync(context: engine_setup.Context, url: string, seed: number | import("engine/engine_types").UIDProvider | null, _allowAddingAnimator?: boolean, prog?: ((ProgressEvent: any) => void) | undefined): Promise<import("three/examples/jsm/loaders/GLTFLoader").GLTF | undefined>;
-        findAnimationsLate(_context: engine_setup.Context, gltf: any, callbackarray: any, allowAddingAnimator?: boolean): void;
-        findAnimations(gltf: import("three/examples/jsm/loaders/GLTFLoader").GLTF, allowAddingAnimator?: boolean): void;
-        tryFindObjectByName(name: any, obj: any, recursive?: boolean): any;
-        tryFindObject(globalObjectIdentifier: any, obj: any, recursive?: boolean): any;
-        tryFindScript(globalObjectIdentifier: any, list?: null): import("engine/engine_types").IComponent | null;
-        NeedleGltfLoader: typeof engine_scenetools.NeedleGltfLoader;
-        GltfLoadEventType: typeof engine_scenetools.GltfLoadEventType;
-        GltfLoadEvent: typeof engine_scenetools.GltfLoadEvent;
-        registerComponent(script: import("engine/engine_types").IComponent, context?: engine_setup.Context | undefined): void;
-        build_scene_functions: {
-            [name: string]: (context: engine_setup.Context) => Promise<void>;
-        };
-        LoadingProgressArgs: typeof engine_setup.LoadingProgressArgs;
-        LoadingOptions: typeof engine_setup.LoadingOptions;
-        ContextArgs: typeof engine_setup.ContextArgs;
-        FrameEvent: typeof engine_setup.FrameEvent;
-        XRSessionMode: typeof engine_setup.XRSessionMode;
-        Context: typeof engine_setup.Context;
-    };
+    const engine: any;
     export { engine as engine };
 }
 declare module "engine/engine_networking_websocket" {
     export {};
 }
+declare module "engine/engine_utils_screenshot" {
+    import { Context } from "engine/engine_setup";
+    import { Camera } from "three";
+    type ImageMimeType = "image/webp" | "image/png";
+    export function screenshot(context: Context, width: number, height: number, mimeType?: ImageMimeType, camera?: Camera | null): string | null;
+}
 declare module "engine-components/BoxCollider" {
     import { BoxCollider } from "engine-components/Collider";
     export default BoxCollider;
@@ -6589,81 +6603,6 @@ declare module "engine-components-experimental/Presentation" {
         update(): void;
     }
 }
-declare module "engine-components-experimental/annotation/LinesManager" {
-    import { Behaviour } from "engine-components/Component";
-    import * as THREE from 'three';
-    import { Color, Material } from "three";
-    import { MeshLine, MeshLineMaterial } from 'three.meshline';
-    export type LineOptions = {
-        material?: Material;
-        options?: LineMaterialOptions;
-    };
-    export type LineMaterialOptions = {
-        map?: THREE.Texture;
-        useMap?: number;
-        alphaMap?: THREE.Texture;
-        color?: Color;
-        opacity?: number;
-        lineWidth?: number;
-    };
-    export class LineInstanceHandler {
-        id: number;
-        points: Array<any>;
-        line: MeshLine;
-        material?: MeshLineMaterial;
-        mesh?: THREE.Mesh;
-        constructor(owner: THREE.Object3D, options?: LineOptions);
-        private static wp;
-        appendPoint(vec: Vec3): Vec3;
-        private defaultLineMaterial;
-    }
-    type Vec3 = {
-        x: number;
-        y: number;
-        z: number;
-    };
-    export type LineHandle = {
-        id: number;
-    };
-    type UpdateLineArgs = {
-        point: Vec3;
-    };
-    export class LinesManager extends Behaviour {
-        startLine(parent?: THREE.Object3D, options?: LineOptions): LineHandle;
-        updateLine(handle: LineHandle, args: UpdateLineArgs): void;
-        endLine(handle: LineHandle, send?: boolean): LineInstanceHandler | undefined;
-        getLine(handle: LineHandle): LineInstanceHandler | undefined;
-        private finished;
-        private inFlight;
-        private buffer;
-        private freeBuffer;
-        awake(): void;
-        private onEnsureLine;
-        private internalStartLine;
-        private sendLineStart;
-        private sendLineUpdate;
-    }
-}
-declare module "engine-components-experimental/annotation/LineDrawer" {
-    import { Behaviour } from "engine-components/Component";
-    import * as THREE from 'three';
-    import { LinesManager } from "engine-components-experimental/annotation/LinesManager";
-    export class LinesDrawer extends Behaviour {
-        lines: LinesManager;
-        colliders?: THREE.Object3D[];
-        alignToSurface: boolean;
-        addToPaintedObject: boolean;
-        private orbit?;
-        start(): void;
-        private _states;
-        update(): void;
-        private updateLine;
-        private _raycastOptions;
-        private static _raycaster;
-        private getHit;
-        private createRandomMaterial;
-    }
-}
 declare module "engine-components-experimental/networking/PlayerSync" {
     import { Behaviour, Component } from "engine-components/Component";
     import { AssetReference } from "engine/engine_addressables";