@needle-tools/engine 2.33.0-pre → 2.34.0-pre

package/CHANGELOG.md

@@ -4,6 +4,15 @@ 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.34.0-pre] - 2022-10-17
+- Add: start adding support for 2D video overlay mode
+- Change: Install threejs from @needle-tools/npm - this removes the requirement to have git installed and should fix a case where pulling the package from github would fail 
+- Change: Move Screensharing aspect mode settings into VideoPlayer component
+- Change: Move ``InstancingUtils`` into ``engine/engine_instancing.ts``
+- Change: BoxCollider now checks if ``attachedRigidBody`` is assigned at start
+- Change: Collision now exposes internal cannon data via ``__internalCollision`` property
+- Fix: EventSystem now properly unsubscribes WebXRController events
+
 ## [2.33.0-pre] - 2022-10-17
 - Add: ScreenCapture has mode for capturing webgl canvas (unfortunately it doesnt seem to work well in Chrome or Firefox yet)
 - Change: move threejs prototype extensions into own file and make available to vanilla js builds

package/dist/needle-engine.d.ts

@@ -414,145 +414,6 @@ declare module "engine-components/Rigidbody" {
         private updateVelocity;
     }
 }
-declare module "engine-components/RendererLightmap" {
-    import { GameObject } from "engine-components/Component";
-    import * as THREE from "three";
-    import { Texture } from "three";
-    import { Context } from "engine/engine_setup";
-    export class RendererLightmap {
-        get lightmap(): Texture | null;
-        set lightmap(tex: Texture | null);
-        lightmapIndex: number;
-        lightmapScaleOffset: THREE.Vector4;
-        private context;
-        private gameObject;
-        private lightmapTexture;
-        private lightmapScaleOffsetUniform;
-        private lightmapUniform;
-        private beforeRenderCallback?;
-        constructor(gameObject: GameObject, context: Context);
-        init(lightmapIndex: number, lightmapScaleOffset: THREE.Vector4, lightmapTexture: THREE.Texture, debug?: boolean): void;
-        bindOnBeforeRender(): void;
-        private onBeforeRenderThreeComplete;
-        private setupLightmap;
-        onBeforeRenderThree(material: THREE.Material): void;
-        private setLightmapDebugMaterial;
-    }
-}
-declare module "engine/extensions/NEEDLE_render_objects" {
-    import { SourceIdentifier } from "engine/engine_gltf";
-    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { Renderer } from "engine-components/Renderer";
-    export class NEEDLE_render_objects implements GLTFLoaderPlugin {
-        private static stencils;
-        static applyStencil(obj?: Renderer | null): void;
-        private parser;
-        private source;
-        constructor(parser: GLTFParser, source: SourceIdentifier);
-        afterRoot(_result: GLTF): Promise<void> | null;
-    }
-    export const EXTENSION_NAME = "NEEDLE_render_objects";
-}
-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_deferred_texture" {
-    import { Material } from "three";
-    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { SourceIdentifier } from "engine/engine_gltf";
-    import { Context } from "engine/engine_setup";
-    export const EXTENSION_NAME = "NEEDLE_deferred_texture";
-    export class NEEDLE_deferred_texture implements GLTFLoaderPlugin {
-        static assignTextureLOD(context: Context, source: SourceIdentifier | undefined, material: Material, level?: number): void;
-        get name(): string;
-        private parser;
-        private sourceId;
-        private context;
-        constructor(parser: GLTFParser, sourceId: SourceIdentifier, context: Context);
-        private _loading;
-        afterRoot(gltf: GLTF): null;
-        private static cache;
-        private static resolved;
-        private static getOrLoadTexture;
-    }
-}
-declare module "engine-components/Renderer" {
-    import { Behaviour } from "engine-components/Component";
-    import * as THREE from "three";
-    import { Texture } from "three";
-    export class FieldWithDefault {
-        path: string | null;
-        asset: object | null;
-        default: any;
-    }
-    export enum RenderState {
-        Both = 0,
-        Back = 1,
-        Front = 2
-    }
-    class SharedMaterialArray {
-        private _renderer;
-        private _targets;
-        is(renderer: Renderer): boolean;
-        constructor(renderer: Renderer);
-        get length(): number;
-        private setMaterial;
-        private getMaterial;
-    }
-    export class Renderer extends Behaviour {
-        receiveShadows: boolean;
-        shadowCastingMode: ShadowCastingMode;
-        lightmapIndex: number;
-        lightmapScaleOffset: THREE.Vector4;
-        enableInstancing: boolean[] | undefined;
-        renderOrder: number[] | undefined;
-        allowOcclusionWhenDynamic: boolean;
-        private _lightmaps?;
-        get material(): THREE.Material;
-        set material(mat: THREE.Material);
-        private _sharedMaterials;
-        get sharedMaterials(): SharedMaterialArray;
-        static get shouldSuppressInstancing(): string | boolean;
-        private _lightmapTextureOverride;
-        get lightmap(): Texture | null;
-        set lightmap(tex: Texture | null | undefined);
-        get hasLightmap(): boolean;
-        awake(): void;
-        private _isInstancingEnabled;
-        private handles;
-        private prevLayers;
-        private clearInstancingState;
-        setInstancingEnabled(enabled: boolean): boolean;
-        start(): void;
-        onEnable(): void;
-        onDisable(): void;
-        onDestroy(): void;
-        applyStencil(): void;
-        onBeforeRenderThree(_renderer: any, _scene: any, _camera: any, _geometry: any, material: any, _group: any): void;
-        onBeforeRender(): void;
-        onAfterRender(): void;
-        private applySettings;
-    }
-    export class MeshRenderer extends Renderer {
-    }
-    export class SkinnedMeshRenderer extends MeshRenderer {
-        awake(): void;
-    }
-    export enum ShadowCastingMode {
-        Off = 0,
-        On = 1,
-        TwoSided = 2,
-        ShadowsOnly = 3
-    }
-    export class InstancingUtil {
-        static markDirty(go: THREE.Object3D | null, recursive?: boolean): void;
-    }
-}
 declare module "engine-components/Collider" {
     import { Behaviour } from "engine-components/Component";
     import { Rigidbody } from "engine-components/Rigidbody";
@@ -562,6 +423,7 @@ declare module "engine-components/Collider" {
         isTrigger: boolean;
         protected _shape: Shape | null;
         awake(): void;
+        start(): void;
         onEnable(): void;
         onDisable(): void;
     }
@@ -576,6 +438,13 @@ declare module "engine-components/Collider" {
         onEnable(): void;
     }
 }
+declare module "engine/engine_instancing" {
+    export const NEED_UPDATE_INSTANCE_KEY: unique symbol;
+    export class InstancingUtil {
+        static isUsingInstancing(instance: THREE.Object3D): boolean;
+        static markDirty(go: THREE.Object3D | null, recursive?: boolean): void;
+    }
+}
 declare module "engine/engine_physics" {
     import * as CANNON from 'cannon-es';
     import * as THREE from 'three';
@@ -669,6 +538,8 @@ declare module "engine/engine_physics" {
         private onEndContact;
     }
     export class Collision {
+        get __internalCollision(): CannonCollision;
+        get __internalInvertedSourceReceiver(): boolean;
         private readonly invert;
         private readonly collision;
         private readonly targetBody;
@@ -1663,6 +1534,14 @@ declare module "engine/engine_gltf_builtin_components" {
     export function writeBuiltinComponentData(comp: Component, context: SerializationContext): object | null;
     export function createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf: any, seed?: number | null | UIDProvider, extension?: NEEDLE_components): Promise<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/shaders/shaderData" {
     export class ShaderData {
         programs: Array<ShaderProgram>;
@@ -2325,6 +2204,7 @@ declare module "engine-components/WebXRController" {
         private static CreateRaycastHitPoint;
         static Create(owner: WebXR, index: number, addTo: GameObject, type: ControllerType): WebXRController;
         static addEventListener(evt: ControllerEvents, callback: (controller: WebXRController, args: any) => void): void;
+        static removeEventListener(evt: ControllerEvents, callback: (controller: WebXRController, args: any) => void): void;
         private static eventSubs;
         webXR: WebXR;
         index: number;
@@ -2829,6 +2709,134 @@ declare module "engine/extensions/NEEDLE_lighting_settings" {
         onDisable(): void;
     }
 }
+declare module "engine-components/RendererLightmap" {
+    import { GameObject } from "engine-components/Component";
+    import * as THREE from "three";
+    import { Texture } from "three";
+    import { Context } from "engine/engine_setup";
+    export class RendererLightmap {
+        get lightmap(): Texture | null;
+        set lightmap(tex: Texture | null);
+        lightmapIndex: number;
+        lightmapScaleOffset: THREE.Vector4;
+        private context;
+        private gameObject;
+        private lightmapTexture;
+        private lightmapScaleOffsetUniform;
+        private lightmapUniform;
+        private beforeRenderCallback?;
+        constructor(gameObject: GameObject, context: Context);
+        init(lightmapIndex: number, lightmapScaleOffset: THREE.Vector4, lightmapTexture: THREE.Texture, debug?: boolean): void;
+        bindOnBeforeRender(): void;
+        private onBeforeRenderThreeComplete;
+        private setupLightmap;
+        onBeforeRenderThree(material: THREE.Material): void;
+        private setLightmapDebugMaterial;
+    }
+}
+declare module "engine/extensions/NEEDLE_deferred_texture" {
+    import { Material } from "three";
+    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    import { SourceIdentifier } from "engine/engine_gltf";
+    import { Context } from "engine/engine_setup";
+    export const EXTENSION_NAME = "NEEDLE_deferred_texture";
+    export class NEEDLE_deferred_texture implements GLTFLoaderPlugin {
+        static assignTextureLOD(context: Context, source: SourceIdentifier | undefined, material: Material, level?: number): void;
+        get name(): string;
+        private parser;
+        private sourceId;
+        private context;
+        constructor(parser: GLTFParser, sourceId: SourceIdentifier, context: Context);
+        private _loading;
+        afterRoot(gltf: GLTF): null;
+        private static cache;
+        private static resolved;
+        private static getOrLoadTexture;
+    }
+}
+declare module "engine-components/Renderer" {
+    import { Behaviour } from "engine-components/Component";
+    import * as THREE from "three";
+    import { Texture } from "three";
+    export class FieldWithDefault {
+        path: string | null;
+        asset: object | null;
+        default: any;
+    }
+    export enum RenderState {
+        Both = 0,
+        Back = 1,
+        Front = 2
+    }
+    class SharedMaterialArray {
+        private _renderer;
+        private _targets;
+        is(renderer: Renderer): boolean;
+        constructor(renderer: Renderer);
+        get length(): number;
+        private setMaterial;
+        private getMaterial;
+    }
+    export class Renderer extends Behaviour {
+        receiveShadows: boolean;
+        shadowCastingMode: ShadowCastingMode;
+        lightmapIndex: number;
+        lightmapScaleOffset: THREE.Vector4;
+        enableInstancing: boolean[] | undefined;
+        renderOrder: number[] | undefined;
+        allowOcclusionWhenDynamic: boolean;
+        private _lightmaps?;
+        get material(): THREE.Material;
+        set material(mat: THREE.Material);
+        private _sharedMaterials;
+        get sharedMaterials(): SharedMaterialArray;
+        static get shouldSuppressInstancing(): string | boolean;
+        private _lightmapTextureOverride;
+        get lightmap(): Texture | null;
+        set lightmap(tex: Texture | null | undefined);
+        get hasLightmap(): boolean;
+        awake(): void;
+        private _isInstancingEnabled;
+        private handles;
+        private prevLayers;
+        private clearInstancingState;
+        setInstancingEnabled(enabled: boolean): boolean;
+        start(): void;
+        onEnable(): void;
+        onDisable(): void;
+        onDestroy(): void;
+        applyStencil(): void;
+        onBeforeRenderThree(_renderer: any, _scene: any, _camera: any, _geometry: any, material: any, _group: any): void;
+        onBeforeRender(): void;
+        onAfterRender(): void;
+        private applySettings;
+    }
+    export class MeshRenderer extends Renderer {
+    }
+    export class SkinnedMeshRenderer extends MeshRenderer {
+        awake(): void;
+    }
+    export enum ShadowCastingMode {
+        Off = 0,
+        On = 1,
+        TwoSided = 2,
+        ShadowsOnly = 3
+    }
+}
+declare module "engine/extensions/NEEDLE_render_objects" {
+    import { SourceIdentifier } from "engine/engine_gltf";
+    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    import { Renderer } from "engine-components/Renderer";
+    export class NEEDLE_render_objects implements GLTFLoaderPlugin {
+        private static stencils;
+        static applyStencil(obj?: Renderer | null): void;
+        private parser;
+        private source;
+        constructor(parser: GLTFParser, source: SourceIdentifier);
+        afterRoot(_result: GLTF): Promise<void> | null;
+    }
+    export const EXTENSION_NAME = "NEEDLE_render_objects";
+}
 declare module "engine/extensions/extensions" {
     import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
     import { NEEDLE_components } from "engine/extensions/NEEDLE_components";
@@ -2939,6 +2947,9 @@ declare module "engine-components/ui/EventSystem" {
         start(): void;
         register(rc: Raycaster): void;
         unregister(rc: Raycaster): void;
+        private _selectStartFn?;
+        private _selectEndFn?;
+        private _selectUpdateFn?;
         onEnable(): void;
         onDisable(): void;
         onPointerDown(): void;
@@ -3768,10 +3779,27 @@ declare module "engine/engine_input_utils" {
     export function awaitInputAsync(): Promise<void>;
     export function awaitInput(cb: any): Promise<void>;
 }
+declare module "engine/engine_create_objects" {
+    import { Mesh, Material } from "three";
+    export enum PrimitiveType {
+        Quad = 0
+    }
+    export type ObjectOptions = {
+        name?: string;
+        material?: Material;
+    };
+    export class ObjectUtils {
+        static createPrimitive(type: PrimitiveType, opts?: ObjectOptions): Mesh;
+    }
+}
 declare module "engine-components/VideoPlayer" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
-    import { Object3D } from "three";
+    export enum AspectMode {
+        None = 0,
+        AdjustHeight = 1,
+        AdjustWidth = 2
+    }
     export enum VideoSource {
         VideoClip = 0,
         Url = 1
@@ -3792,6 +3820,7 @@ declare module "engine-components/VideoPlayer" {
         renderer: THREE.Object3D | null;
         playOnAwake: boolean;
         playOnEnable?: boolean;
+        aspectMode: AspectMode;
         private renderMode?;
         private targetMaterialProperty?;
         private targetMaterialRenderer?;
@@ -3808,13 +3837,14 @@ declare module "engine-components/VideoPlayer" {
         get isPlaying(): boolean;
         get crossOrigin(): string | null;
         set crossOrigin(val: string | null);
+        get videoTexture(): THREE.VideoTexture | null;
         private _crossOrigin;
         private audioOutputMode;
         private source;
         private clip?;
         private url?;
         private videoElement;
-        private videoTexture;
+        private _videoTexture;
         private videoMaterial;
         private _isPlaying;
         private wasPlaying;
@@ -3830,12 +3860,17 @@ declare module "engine-components/VideoPlayer" {
         stop(): void;
         pause(): void;
         create(playAutomatically: boolean): void;
+        updateAspect(): void;
+        private _overlay;
+        get screenspace(): boolean;
+        set screenspace(val: boolean);
         private _targetObjects;
-        getTargetObjects(): Array<Object3D>;
         private createVideoElement;
         private handleBeginPlaying;
         private updateVideoElementSettings;
         private updateVideoElementStyles;
+        private _updateAspectRoutineId;
+        private updateAspectImpl;
     }
 }
 declare module "engine-components/ScreenCapture" {
@@ -3852,16 +3887,10 @@ declare module "engine-components/ScreenCapture" {
         Sending = 1,
         Receiving = 2
     }
-    export enum AspectMode {
-        None = 0,
-        AdjustHeight = 1,
-        AdjustWidth = 2
-    }
     export class ScreenCapture extends Behaviour implements IPointerClickHandler {
         onPointerClick(): void;
         videoPlayer?: VideoPlayer;
         device: ScreenCaptureDevice;
-        aspectMode: AspectMode;
         get currentScream(): MediaStream | null;
         get currentMode(): ScreenCaptureMode;
         get isSending(): boolean | undefined;
@@ -3877,10 +3906,6 @@ declare module "engine-components/ScreenCapture" {
         private setVideo;
         private onReceiveVideo;
         private tryShareUserCamera;
-        private _targetObjects?;
-        private updateAspect;
-        private _updateAspectRoutineId;
-        private updateAspectImpl;
     }
 }
 declare module "engine-components/ShadowCatcher" {
@@ -5042,7 +5067,6 @@ declare module "engine-components/codegen/components" {
     export { Renderer } from "engine-components/Renderer";
     export { MeshRenderer } from "engine-components/Renderer";
     export { SkinnedMeshRenderer } from "engine-components/Renderer";
-    export { InstancingUtil } from "engine-components/Renderer";
     export { RendererLightmap } from "engine-components/RendererLightmap";
     export { Rigidbody } from "engine-components/Rigidbody";
     export { ScreenCapture } from "engine-components/ScreenCapture";