@needle-tools/engine 3.0.0-alpha → 3.0.1-alpha

package/src/engine/engine_scenetools.ts

@@ -24,11 +24,11 @@ export class NeedleGltfLoader implements INeedleGltfLoader {
         return writeBuiltinComponentData(comp, context);
     }
 
-    parseSync(context: Context, data, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined> {
+    parseSync(context: Context, data : string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined> {
         return parseSync(context, data, path, seed);
     }
-    loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator: boolean, prog?: ((ProgressEvent: any) => void) | undefined): Promise<GLTF | undefined> {
-        return loadSync(context, url, seed, _allowAddingAnimator, prog);
+    loadSync(context: Context, url: string, sourceId:string, seed: number | UIDProvider | null, prog?: ((ProgressEvent: any) => void) | undefined): Promise<GLTF | undefined> {
+        return loadSync(context, url, sourceId, seed, prog);
     }
 }
 
@@ -87,7 +87,7 @@ function invokeEvents(type: GltfLoadEventType, event: GltfLoadEvent) {
 
 async function handleLoadedGltf(context: Context, gltfId: string, gltf, seed: number | null | UIDProvider, componentsExtension) {
     if (printGltf)
-        console.log(gltf);
+        console.warn("glTF", gltfId, gltf);
     await getLoader().createBuiltinComponents(context, gltfId, gltf, seed, componentsExtension);
 
     // load and assign animation
@@ -102,7 +102,7 @@ export function createGLTFLoader(url: string, context: Context) {
     return loader;
 }
 
-export function parseSync(context: Context, data, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined> {
+export function parseSync(context: Context, data : string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined> {
     if (typeof path !== "string") {
         console.warn("Parse gltf binary without path, this might lead to errors in resolving extensions. Please provide the source path of the gltf/glb file", path, typeof path);
     }
@@ -131,7 +131,7 @@ export function parseSync(context: Context, data, path: string, seed: number | U
     });
 }
 
-export function loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator: boolean = false, prog?: (ProgressEvent) => void): Promise<GLTF | undefined> {
+export function loadSync(context: Context, url: string, sourceId:string, seed: number | UIDProvider | null, prog?: (ProgressEvent) => void): Promise<GLTF | undefined> {
     // better to create new loaders every time
     // (maybe we can cache them...)
     // but due to the async nature and potentially triggering multiple loads at the same time
@@ -145,7 +145,7 @@ export function loadSync(context: Context, url: string, seed: number | UIDProvid
             invokeEvents(GltfLoadEventType.BeforeLoad, new GltfLoadEvent(context, url, loader));
             loader.load(url, async data => {
                 invokeEvents(GltfLoadEventType.AfterLoaded, new GltfLoadEvent(context, url, loader, data));
-                await handleLoadedGltf(context, url, data, seed, componentsExtension);
+                await handleLoadedGltf(context, sourceId, data, seed, componentsExtension);
                 invokeEvents(GltfLoadEventType.FinishedSetup, new GltfLoadEvent(context, url, loader, data));
                 registerPrewarmObject(data.scene, context);
                 resolve(data);

package/src/engine/engine_time.ts

@@ -1,11 +1,12 @@
 import { Clock } from 'three'
 import { getParam } from './engine_utils';
+import { ITime } from './engine_types';
 
 const timescaleUrl = getParam("timescale");
 let timeScale = 1;
 if (typeof timescaleUrl === "number") timeScale = timescaleUrl;
 
-export class Time {
+export class Time implements ITime {
 
     deltaTime = 0;
     time = 0;

package/src/engine/engine_types.ts

@@ -27,9 +27,13 @@ export declare type CoroutineData = {
     chained?: Array<Generator>
 }
 
+export interface ITime {
+    get time(): number;
+}
 
 export interface IContext {
     alias?: string | null;
+    hash?:string;
 
     scene: Scene;
     renderer: WebGLRenderer;
@@ -37,6 +41,8 @@ export interface IContext {
     mainCameraComponent: ICamera | undefined;
     domElement: HTMLElement;
 
+    time: ITime;
+
     scripts: IComponent[];
     scripts_pausedChanged: IComponent[];
     // scripts with update event

package/src/engine-components/Animation.ts

@@ -145,7 +145,7 @@ export class Animation extends Behaviour {
         return false;
     }
 
-    play(clipOrNumber: AnimationClip | number | string | undefined, options?: PlayOptions): Promise<AnimationAction> | void {
+    play(clipOrNumber: AnimationClip | number | string | undefined = 0, options?: PlayOptions): Promise<AnimationAction> | void {
         if (debug) console.log("PLAY", clipOrNumber)
         this.init();
         if (!this.mixer) {
@@ -171,8 +171,8 @@ export class Animation extends Behaviour {
         if (!options) options = {};
         if (!options.minMaxOffsetNormalized) options.minMaxOffsetNormalized = this.minMaxOffsetNormalized;
         if (!options.minMaxSpeed) options.minMaxSpeed = this.minMaxSpeed;
-        if (!options.loop) options.loop = this.loop;
-        if (!options.clampWhenFinished) options.clampWhenFinished = this.clampWhenFinished;
+        if (options.loop === undefined) options.loop = this.loop;
+        if (options.clampWhenFinished === undefined) options.clampWhenFinished = this.clampWhenFinished;
         for (const act of this.actions) {
             if (act.getClip() === clip) {
                 return this.internalOnPlay(act, options);

package/src/engine-components/Renderer.ts

@@ -639,7 +639,7 @@ export class Renderer extends Behaviour implements IRenderer {
         }
     }
 
-    private applySettings(go: THREE.Object3D) {
+    applySettings(go: THREE.Object3D) {
         go.receiveShadow = this.receiveShadows;
         if (this.shadowCastingMode == ShadowCastingMode.On) {
             go.castShadow = true;
@@ -734,15 +734,16 @@ class InstancingHandler {
     public setup(renderer: Renderer, obj: THREE.Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level: number = 0)
         : InstanceHandle[] | null {
 
+        // make sure setting casting settings are applied so when we add the mesh to the InstancedMesh we can ask for the correct cast shadow setting
+        renderer.applySettings(obj);
         const res = this.tryCreateOrAddInstance(obj, context, args);
         if (res) {
             renderer.loadProgressiveTextures(res.instancer.material);
             if (handlesArray === null) handlesArray = [];
             handlesArray.push(res);
-            return handlesArray;
         }
 
-        if (level <= 0 && obj.type !== "Mesh") {
+        else if (level <= 0 && obj.type !== "Mesh") {
             const nextLevel = level + 1;
             for (const ch of obj.children) {
                 handlesArray = this.setup(renderer, ch, context, handlesArray, args, nextLevel);
@@ -799,10 +800,8 @@ class InstancingHandler {
         let previousMatrix: THREE.Matrix4 = obj.matrixWorld.clone();
         const matrixChangeWrapper = (a: Matrix4, b: Matrix4) => {
             const newMatrixWorld = original(a, b);
-            // console.warn("MULT", obj.matrixWorldNeedsUpdate);
             if (obj[NEED_UPDATE_INSTANCE_KEY] || previousMatrix.equals(newMatrixWorld) === false) {
                 previousMatrix.copy(newMatrixWorld)
-                // handle.setMatrix(newMatrixWorld);
                 obj[NEED_UPDATE_INSTANCE_KEY] = true;
             }
             return newMatrixWorld;
@@ -865,6 +864,13 @@ class InstanceHandle {
 
 class InstancedMeshRenderer {
 
+    set castShadow(val: boolean) {
+        this.inst.castShadow = val;
+    }
+    set receiveShadow(val: boolean) {
+        this.inst.receiveShadow = val;
+    }
+
     public name: string = "";
     public geo: THREE.BufferGeometry;
     public material: THREE.Material;
@@ -915,6 +921,14 @@ class InstancedMeshRenderer {
             return null;
         }
         const handle = new InstanceHandle(-1, obj, this);
+
+        if (obj.castShadow === true && this.inst.castShadow === false) {
+            this.inst.castShadow = true;
+        }
+        if (obj.receiveShadow === true && this.inst.receiveShadow === false) {
+            this.inst.receiveShadow = true;
+        }
+
         this.add(handle);
         return handle;
     }

package/src/engine-components/api.ts

@@ -0,0 +1 @@
+export * from "./ui/PointerEvents"

package/src/engine-components/postprocessing/Effects/ScreenspaceAmbientOcclusion.ts

@@ -1,5 +1,5 @@
 import { BlendFunction, DepthDownsamplingPass, Effect, NormalPass, SSAOEffect } from "postprocessing";
-import { NeverDepth, PerspectiveCamera } from "three";
+import { Color, NeverDepth, PerspectiveCamera } from "three";
 import { serializable } from "../../../engine/engine_serialization";
 import { EffectProviderResult, PostProcessingEffect } from "../PostProcessingEffect";
 import { VolumeParameter } from "../VolumeParameter";
@@ -21,6 +21,12 @@ export class ScreenSpaceAmbientOcclusion extends PostProcessingEffect {
     @serializable(VolumeParameter)
     samples!: VolumeParameter;
 
+    @serializable(VolumeParameter)
+    color!: VolumeParameter;
+
+    @serializable(VolumeParameter)
+    luminanceInfluence!: VolumeParameter;
+
     onBeforeRender() {
         if (this._ssao && this.context.mainCamera instanceof PerspectiveCamera) {
             const fadeDistance = this.context.mainCamera.far - this.context.mainCamera.near;
@@ -48,6 +54,7 @@ export class ScreenSpaceAmbientOcclusion extends PostProcessingEffect {
             worldProximityFalloff: 2,
             intensity: 1,
             blendFunction: BlendFunction.MULTIPLY,
+            luminanceInfluence: .5,
         });
 
         this.intensity.onValueChanged = newValue => {
@@ -59,6 +66,13 @@ export class ScreenSpaceAmbientOcclusion extends PostProcessingEffect {
         this.samples.onValueChanged = newValue => {
             ssao.samples = newValue;
         }
+        this.color.onValueChanged = newValue => {
+            if (!ssao.color) ssao.color = new Color();
+            ssao.color.copy(newValue);
+        }
+        this.luminanceInfluence.onValueChanged = newValue => {
+            ssao.luminanceInfluence = newValue;
+        }
 
         const arr = new Array();
         arr.push(normalPass);

package/src/engine-components/postprocessing/PostProcessingHandler.ts

@@ -193,7 +193,7 @@ export class PostProcessingHandler {
 }
 
 
-const effectsOrder: Array<Constructor<Effect | Pass>> = [
+export const effectsOrder: Array<Constructor<Effect | Pass>> = [
     NormalPass,
     DepthDownsamplingPass,
     SSAOEffect,

package/src/engine-components/ui/Text.ts

@@ -466,7 +466,7 @@ export class Text extends Graphic {
     }
 
     private setFont(opts: any, fontStyle: FontStyle) {
-        const name = this.getFontName(fontStyle);
+        const name = this.getFontStyleName(fontStyle);
         let family = name;
         if (!family?.endsWith("-msdf.json")) family += "-msdf.json";
         opts.fontFamily = family;
@@ -476,23 +476,47 @@ export class Text extends Graphic {
         opts.fontTexture = texture;
     }
 
-    private getFontName(_fontStyle: FontStyle): string | null {
+    private getFontStyleName(style: FontStyle): string | null {
         if (!this.font) return null;
-        // switch (fontStyle) {
-        //     case FontStyle.Normal:
-        //         return this.font;
-        //     case FontStyle.Bold:
-        //         if (!this.font.includes("-bold"))
-        //             return this.font + "-bold";
-        //     case FontStyle.Italic:
-        //         if (!this.font.includes("-italic"))
-        //             return this.font + "-italic";
-        //     case FontStyle.BoldAndItalic:
-        //         if (!this.font.includes("-bold-italic"))
-        //             return this.font + "-bold-italic";
-        // }
-        this.font = getPath(this.sourceId, this.font);
-        return this.font;
+        let fontName = this.font;
+
+        // if a font path has a known suffix we remove it
+        if (fontName.endsWith("-regular")) {
+            if (style === FontStyle.Normal) return getPath(this.sourceId, fontName);
+                fontName = fontName.substring(0, fontName.length - "-regular".length);
+        }
+        else if (fontName.endsWith("-bold")) {
+            if (style === FontStyle.Bold)return getPath(this.sourceId, fontName);
+                fontName = fontName.substring(0, fontName.length - "-bold".length);
+        }
+        else if (fontName.endsWith("-italic")) {
+            if (style === FontStyle.Italic)return getPath(this.sourceId, fontName);
+                fontName = fontName.substring(0, fontName.length - "-italic".length);
+        }
+        else if (fontName.endsWith("-bolditalic")) {
+            if (style === FontStyle.BoldAndItalic)return getPath(this.sourceId, fontName);
+                fontName = fontName.substring(0, fontName.length - "-bolditalic".length);
+        }
+        else
+            // If a font does not have a specific style suffic we dont support getting the correct font style
+            return getPath(this.sourceId, fontName);
+
+        switch (style) {
+            case FontStyle.Normal:
+                fontName += "-regular";
+                break;
+            case FontStyle.Bold:
+                fontName += "-bold";
+                break;
+            case FontStyle.Italic:
+                fontName += "-italic";
+                break;
+            case FontStyle.BoldAndItalic:
+                fontName += "-bolditalic";
+                break;
+        }
+
+        return getPath(this.sourceId, fontName);
     }
 }
 

package/src/needle-engine.ts

@@ -11,6 +11,7 @@ export { GameObject, Behaviour } from "./engine-components/Component";
 export { serializable, serializeable } from "./engine/engine_serialization_decorator";
 export { Collision } from "./engine/engine_types";
 export * from "./engine/api";
+export * from "./engine-components/api";
 export * from "./engine-components/codegen/components";
 export * from "./engine-components/js-extensions/Object3D";