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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.0.0-alpha.1",
+    "version": "3.0.1-alpha",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development, and can be deployed anywhere. It is flexible, extensible, and collaboration and XR come naturally.",
     "main": "dist/needle-engine.umd.cjs",
     "module": "lib/needle-engine.js",
@@ -57,8 +57,8 @@
         "flatbuffers": "2.0.4",
         "md5": "^2.3.0",
         "peerjs": "1.3.2",
-        "simplex-noise": "^4.0.1",
         "postprocessing": "^6.30.1",
+        "simplex-noise": "^4.0.1",
         "stats.js": "^0.17.0",
         "three": "npm:@needle-tools/three@^0.146.6",
         "three-mesh-ui": "^6.4.5",
@@ -72,10 +72,9 @@
         "@needle-tools/helper": "^0.4.5",
         "@needle-tools/needle-component-compiler": "1.9.3",
         "@types/three": "0.146.0",
-        "copy-files-from-to": "^3.7.0",
         "esbuild": "^0.15.10",
         "esbuild-node-externals": "^1.5.0",
-        "fs-extra": "^11.1.0",
+        "fs-extra": "^11.1.1",
         "jsdoc-babel": "^0.5.0",
         "jsdoc-to-markdown": "^7.1.1",
         "madge": "^5.0.1",

package/plugins/vite/copyfiles.js

@@ -1,7 +1,6 @@
 
-import { copy } from 'fs-extra'
-import { resolve } from 'path'
-import { existsSync } from 'fs';
+import { resolve, join } from 'path'
+import { existsSync, statSync, mkdirSync, readdirSync, copyFileSync, mkdir } from 'fs';
 
 
 /** copy files on build from assets to dist */
@@ -11,32 +10,60 @@ export const needleCopyFiles = (command, config, userSettings) => {
         return;
     }
 
+    const copyIncludesFromEngine = config?.copyIncludesFromEngine ?? true;
+
     return {
         name: 'needle-copy-files',
         apply: 'build',
         async closeBundle() {
             const baseDir = process.cwd();
+            const pluginName = "needle-copy-files";
 
             const outdirName = "dist";
             const outDir = resolve(baseDir, outdirName);
             if (!existsSync(outDir)) {
-                console.log(`No ${outdirName} folder found, skipping copy files: ${outDir}`);
-                return;
+                mkdirSync(outDir);
+            }
+
+            if (copyIncludesFromEngine !== false) {
+                // copy include from engine
+                const engineIncludeDir = resolve(baseDir, 'node_modules', '@needle-tools', 'engine', 'src', 'include');
+                if (existsSync(engineIncludeDir)) {
+                    console.log(`[${pluginName}] - Copy engine include to ${baseDir}/include`)
+                    const targetDir = resolve(baseDir, 'include');
+                    copyRecursiveSync(engineIncludeDir, targetDir);
+                }
             }
+
             // copy assets dir
             const assetsDir = resolve(baseDir, 'assets');
             if (existsSync(assetsDir)) {
-                console.log(`Copy assets to ${outdirName}/assets`)
+                console.log(`[${pluginName}] - Copy assets to ${outdirName}/assets`)
                 const targetDir = resolve(outDir, 'assets');
-                await copy(assetsDir, targetDir, { overwrite: true });
+                copyRecursiveSync(assetsDir, targetDir);
             }
             // copy include dir
             const includeDir = resolve(baseDir, 'include');
             if (existsSync(includeDir)) {
-                console.log(`Copy include to ${outdirName}/include`)
+                console.log(`[${pluginName}] - Copy include to ${outdirName}/include`)
                 const targetDir = resolve(outDir, 'include');
-                await copy(includeDir, targetDir, { overwrite: true });
+                copyRecursiveSync(includeDir, targetDir);
             }
         }
     }
-}
+}
+
+function copyRecursiveSync(src, dest) {
+    var exists = existsSync(src);
+    var stats = exists && statSync(src);
+    var isDirectory = exists && stats.isDirectory();
+    if (isDirectory) {
+        if (!existsSync(dest))
+            mkdirSync(dest);
+        readdirSync(src).forEach(function (childItemName) {
+            copyRecursiveSync(join(src, childItemName), join(dest, childItemName));
+        });
+    } else {
+        copyFileSync(src, dest);
+    }
+};

package/plugins/vite/reload.js

@@ -43,7 +43,8 @@ export const needleReload = (command, config, userSettings) => {
             else if (!config.server.watch.ignored) config.server.watch.ignored = [];
             for (const pattern of ignorePatterns)
                 config.server.watch.ignored.push(pattern);
-            setTimeout(() => console.log("Updated server ignore patterns: ", config.server.watch.ignored), 100);
+            if(config?.debug === true || userSettings?.debug === true)
+                setTimeout(() => console.log("Updated server ignore patterns: ", config.server.watch.ignored), 100);
         },
         handleHotUpdate(args) {
             args.buildDirectory = buildDirectory;

package/src/engine/engine_addressables.ts

@@ -163,7 +163,7 @@ export class AssetReference {
         }
         else {
             if (debug) console.log("Load async", this.uri);
-            this._loading = getLoader().loadSync(context, this._hashedUri, null, true, prog => {
+            this._loading = getLoader().loadSync(context, this._hashedUri, this.uri, null, prog => {
                 this.raiseProgressEvent(prog);
             });
         }

package/src/engine/engine_context.ts

@@ -87,15 +87,12 @@ export function registerComponent(script: IComponent, context?: Context) {
 
 export class Context implements IContext {
 
-	private static _current: Context;
-
 	static get Current(): Context {
-		return this._current;
+		return ContextRegistry.Current as Context;
 	}
 
 	static set Current(context: Context) {
 		ContextRegistry.Current = context;
-		this._current = context;
 	}
 
 	name: string;
@@ -307,7 +304,7 @@ export class Context implements IContext {
 	// private _requestSizeUpdate : boolean = false;
 
 	updateSize() {
-		if (!this.isManagedExternally && !this.renderer.xr.isPresenting) {
+		if (!this.isManagedExternally && this.renderer.xr?.isPresenting === false) {
 			this._sizeChanged = false;
 			const scaleFactor = this.resolutionScaleFactor;
 			const width = this.domWidth * scaleFactor;
@@ -516,10 +513,10 @@ export class Context implements IContext {
 		if (!this.isManagedExternally)
 			this.domElement.prepend(this.renderer.domElement);
 
-		Context._current = this;
+		Context.Current = this;
 
 		// Setup
-		Context._current = this;
+		Context.Current = this;
 		for (let i = 0; i < this.new_scripts.length; i++) {
 			const script = this.new_scripts[i];
 			if (script.gameObject !== undefined && script.gameObject !== null) {
@@ -546,13 +543,13 @@ export class Context implements IContext {
 		// resolve post setup callbacks (things that rely on threejs objects having references to components)
 		if (this.post_setup_callbacks) {
 			for (let i = 0; i < this.post_setup_callbacks.length; i++) {
-				Context._current = this;
+				Context.Current = this;
 				await this.post_setup_callbacks[i](this);
 			}
 		}
 
 		if (!this.mainCamera) {
-			Context._current = this;
+			Context.Current = this;
 			let camera: ICamera | null = null;
 			foreachComponent(this.scene, comp => {
 				const cam = comp as ICamera;
@@ -577,7 +574,7 @@ export class Context implements IContext {
 			}
 		}
 
-		Context._current = this;
+		Context.Current = this;
 		looputils.processNewScripts(this);
 
 		// const mainCam = this.mainCameraComponent as Camera;
@@ -624,10 +621,10 @@ export class Context implements IContext {
 		
 		this._stats?.begin();
 
-		Context._current = this;
+		Context.Current = this;
 		if (this.onHandlePaused()) return;
 
-		Context._current = this;
+		Context.Current = this;
 		this.time.update();
 		if (debugframerate)
 			console.log("FPS", (this.time.smoothedFps).toFixed(0));
@@ -655,7 +652,7 @@ export class Context implements IContext {
 			const script = this.scripts_earlyUpdate[i];
 			if (!script.activeAndEnabled) continue;
 			if (script.earlyUpdate !== undefined) {
-				Context._current = this;
+				Context.Current = this;
 				script.earlyUpdate();
 			}
 		}
@@ -668,7 +665,7 @@ export class Context implements IContext {
 			const script = this.scripts_update[i];
 			if (!script.activeAndEnabled) continue;
 			if (script.update !== undefined) {
-				Context._current = this;
+				Context.Current = this;
 				script.update();
 			}
 		}
@@ -681,7 +678,7 @@ export class Context implements IContext {
 			const script = this.scripts_lateUpdate[i];
 			if (!script.activeAndEnabled) continue;
 			if (script.lateUpdate !== undefined) {
-				Context._current = this;
+				Context.Current = this;
 				script.lateUpdate();
 			}
 		}
@@ -712,7 +709,7 @@ export class Context implements IContext {
 				if (!script.activeAndEnabled) continue;
 				// if(script.isActiveAndEnabled === false) continue;
 				if (script.onBeforeRender !== undefined) {
-					Context._current = this;
+					Context.Current = this;
 					script.onBeforeRender(frame);
 				}
 			}
@@ -741,7 +738,7 @@ export class Context implements IContext {
 				const script = this.scripts_onAfterRender[i];
 				if (!script.activeAndEnabled) continue;
 				if (script.onAfterRender !== undefined) {
-					Context._current = this;
+					Context.Current = this;
 					script.onAfterRender();
 				}
 			}
@@ -798,7 +795,7 @@ export class Context implements IContext {
 				const script = this.scripts_pausedChanged[i];
 				if (!script.activeAndEnabled) continue;
 				if (script.onPausedChanged !== undefined) {
-					Context._current = this;
+					Context.Current = this;
 					script.onPausedChanged(paused, this._wasPaused);
 				}
 			}

package/src/engine/engine_context_registry.ts

@@ -14,7 +14,13 @@ export type ContextEventArgs = {
 export type ContextCallback = (evt: ContextEventArgs) => void;
 
 export class ContextRegistry {
-    static Current: IContext;
+
+    static get Current(): IContext{
+        return globalThis["NeedleEngine.Context.Current"]
+    }
+    static set Current(ctx: IContext) {
+        globalThis["NeedleEngine.Context.Current"] = ctx;
+    }
 
     static Registered: IContext[] = [];
 

package/src/engine/engine_element.ts

@@ -240,7 +240,7 @@ export class EngineElement extends HTMLElement implements INeedleEngineComponent
                             totalProgress01: this._loadingProgress01
                         }
                     }
-                    const res = await loader.loadSync(ctx, url, hash, false, prog => {
+                    const res = await loader.loadSync(ctx, url, url, hash, prog => {
                         // Calc progress
                         progress.progress = prog;
                         this._loadingProgress01 = calculateProgress01(progress);

package/src/engine/engine_gltf.ts

@@ -8,8 +8,8 @@ import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js'
 export interface INeedleGltfLoader {
     createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf, seed: number | null | UIDProvider, extension?: NEEDLE_components): Promise<void>
     writeBuiltinComponentData(comp: object, context: SerializationContext);
-    parseSync(context: Context, data, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
-    loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator: boolean, prog?: (prog : ProgressEvent) => void): Promise<GLTF | undefined>
+    parseSync(context: Context, data : string | ArrayBuffer, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
+    loadSync(context: Context, url: string, sourceId:string, seed: number | UIDProvider | null, prog?: (prog : ProgressEvent) => void): Promise<GLTF | undefined>
 }
 
 let gltfLoader: INeedleGltfLoader;

package/src/engine/engine_mainloop_utils.ts

@@ -370,17 +370,19 @@ export function runPrewarm(context: IContext) {
     if (cam) {
         if (debugPrewarm) console.log("prewarm", list.length, "objects", [...list]);
         const renderer = context.renderer;
-        const scene = context.scene;
-        renderer.compile(scene, cam!)
-        prewarmTarget ??= new WebGLCubeRenderTarget(64)
-        prewarmCamera ??= new CubeCamera(0.001, 9999999, prewarmTarget);
-        prewarmCamera.update(renderer, scene);
-        for (const obj of list) {
-            obj[$prewarmedFlag] = true;
-            obj[$waitingForPrewarm] = false;
+        if (renderer.compile) {
+            const scene = context.scene;
+            renderer.compile(scene, cam!)
+            prewarmTarget ??= new WebGLCubeRenderTarget(64)
+            prewarmCamera ??= new CubeCamera(0.001, 9999999, prewarmTarget);
+            prewarmCamera.update(renderer, scene);
+            for (const obj of list) {
+                obj[$prewarmedFlag] = true;
+                obj[$waitingForPrewarm] = false;
+            }
+            list.length = 0;
+            if (debugPrewarm) console.log("prewarm done");
         }
-        list.length = 0;
-        if (debugPrewarm) console.log("prewarm done");
     }
 }
 

package/src/engine/engine_networking_files.ts

@@ -48,13 +48,13 @@ export async function addFile(file: File, context: Context, backendUrl?: string)
     if (name.endsWith(".gltf") || name.endsWith(".glb")) {
         return new Promise((resolve, _reject) => {
             const reader = new FileReader()
-            reader.readAsDataURL(file);
+            reader.readAsArrayBuffer(file);
             reader.onloadend = async (_ev: ProgressEvent<FileReader>) => {
-                const content = reader.result as string;
+                const content = reader.result as ArrayBuffer;
                 // first load it locally
                 const seed = generateSeed();
                 const prov = new InstantiateIdProvider(seed);
-                const gltf: GLTF = await getLoader().loadSync(context, content, prov, true) as GLTF;
+                const gltf: GLTF = await getLoader().parseSync(context, content, file.name, prov) as GLTF;
                 if (gltf && gltf.scene) {
                     const obj = gltf.scene as unknown as IGameObject;
                     // if we dont have a guid yet (because components guids are actually created in a callback a bit later)
@@ -85,7 +85,8 @@ export async function addFileFromUrl(url: URL, context: Context): Promise<GLTF |
     return new Promise(async (resolve, _reject) => {
         const seed = generateSeed();
         const prov = new InstantiateIdProvider(seed);
-        const gltf: GLTF = await getLoader().loadSync(context, url.toString(), prov, true) as GLTF;
+        const urlStr = url.toString();
+        const gltf: GLTF = await getLoader().loadSync(context, urlStr, urlStr, prov) as GLTF;
         if (gltf && gltf.scene) {
             const obj = gltf.scene as unknown as IGameObject;
             // handleUpload(context.connection, file, seed, obj); // TODO needs to upload the URL only and store that

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,