@hology/core 0.0.20

package/dist/rendering.js

@@ -0,0 +1,5 @@
+import*as e from"three";import{Mesh as t,Matrix4 as i,ShaderMaterial as r,PerspectiveCamera as s,ShaderChunk as n}from"three";import{EffectComposer as a}from"three-stdlib";import{RenderPass as o}from"three-stdlib";import{ShaderPass as h}from"three-stdlib";import{FXAAShader as d}from"three-stdlib";import{CSM as l}from"three-stdlib";import{CSMUtil as c}from"./csm";import{GammaCorrectionShader as m}from"three-stdlib";import{Reflector as p}from"three-stdlib";import{depthUniformName as u,resolutionUniformName as g,supportsDepthTextureExtension as v,nearUniformName as f,farUniformName as w}from"./shader-nodes/depth";import{elapsedTimeUniformName as x}from"./shader-nodes/time";import{OutlinePass as b}from"./utils/three/outline-pass";import C from"./utils/three/stats";import{lambertVertexShaderOverride as R}from"./rendering/shader-override";import{DepthPass as y}from"./utils/three/depth-pass";const P=new e.MeshDepthMaterial;P.depthPacking=e.RGBADepthPacking,P.blending=e.NoBlending;n.lights_pars_begin;n.lights_lambert_vertex=R;export class RenderingView{setPaused(e){this.paused=e}resizeRender(){this.previousClientWith===this.container.clientWidth&&this.previousClientHeight===this.container.clientHeight||(this.camera instanceof s&&(this.camera.aspect=this.container.clientWidth/this.container.clientHeight,this.camera.updateProjectionMatrix()),this.renderer.setPixelRatio(window.devicePixelRatio*this.resolutionScale),this.renderer.setSize(this.container.clientWidth,this.container.clientHeight),this.composer.setSize(this.container.clientWidth*this.resolutionScale,this.container.clientHeight*this.resolutionScale),this.previousClientWith=this.container.clientWidth,this.previousClientHeight=this.container.clientHeight)}constructor(t,i={}){this.container=t,this.options=i,this.windowVisible=!0,this.running=!0,this.paused=!1,this.fpsCap=null,this.resolutionScale=1,this.onResize=()=>{this.resizeRender(),this.paused||this.composer.render()},this.onVisiblityChane=()=>{this.windowVisible=!document.hidden},this.isDepthTextureExtensionSupported=!1,this.onLoopCallbacks=[],this.insetHeight=200,this.insetWidth=this.insetHeight*(16/9),this.insetOffsetY=250,this.insetMargin=10,this.maxInsetCameras=4,this.overlayCameras=new Set,window.renderer=this.renderer=new e.WebGLRenderer({antialias:!0,powerPreference:"high-performance"}),this.scene=new e.Scene,this.renderer.setPixelRatio(window.devicePixelRatio*this.resolutionScale),this.renderer.setSize(t.clientWidth,t.clientHeight),this.composer=new a(this.renderer);var r=t.clientWidth/t.clientHeight;const s=new e.PerspectiveCamera(45,r,.5,500);s.layers.enable(19),this.setCamera(s),this.renderer.shadowMap.enabled=!0,this.renderer.shadowMap.type=e.PCFSoftShadowMap,this.renderer.shadowMap.autoUpdate=!1,this.renderer.outputEncoding=e.sRGBEncoding,this.renderer.physicallyCorrectLights=!1,this.renderer.gammaFactor=1.4,c.renderingView=this,c.patchThreeAdd(),this.isDepthTextureExtensionSupported=v(this.renderer),t.replaceChildren(this.renderer.domElement),this.setupEventListeners(),this.depthRenderTarget=RenderingView.createDepthRenderTarget(this.renderer,this.container);const n=new o(this.scene,this.camera);if(this.composer.addPass(n),this.outlinePass=new b(new e.Vector2(t.clientWidth,t.clientHeight),this.scene,this.camera),!0===i.enableOutlines){this.outlinePass.edgeThickness=0,this.outlinePass.edgeGlow=0,this.outlinePass.edgeThickness=1.5,this.outlinePass.edgeStrength=5,this.outlinePass.clear=!1,this.composer.addPass(this.outlinePass);const e=new h(d);e.uniforms.resolution.value.set(1/t.clientWidth,1/t.clientHeight),this.composer.addPass(e);var l=new h(m);l.clear=!1,this.composer.addPass(l)}}setCamera(t){this.camera=t,this.composer.passes.forEach((e=>{e instanceof o?e.camera=t:e instanceof b?e.renderCamera=t:e instanceof y&&(e.camera=t)})),null==this.csm?this.csm=new l({maxFar:200,lightFar:300,cascades:5,shadowMapSize:2048,lightDirection:new e.Vector3(.5,-1,-.6).normalize(),lightIntensity:.5,camera:this.camera,parent:this.scene}):(this.csm.camera=this.camera,this.camera instanceof s&&(this.csm.maxFar=this.camera.far)),this.csm.updateFrustums()}setSelectedObjects(e){const t=new Map;for(const i of e)t.set(i.uuid,i);for(const i of e)i.traverse((e=>{e.uuid!==i.uuid&&t.has(e.uuid)&&t.delete(e.uuid)}));this.outlinePass.selectedObjects=Array.from(t.values())}static createDepthRenderTarget(t,i){var r=!!t.extensions.get("WEBGL_depth_texture");const s=new e.WebGLRenderTarget(i.clientWidth*t.getPixelRatio(),i.clientHeight*t.getPixelRatio());return s.texture.minFilter=e.NearestFilter,s.texture.magFilter=e.NearestFilter,s.texture.generateMipmaps=!1,s.stencilBuffer=!1,!0===r&&(s.depthTexture=new e.DepthTexture(128,128),s.depthTexture.type=e.UnsignedShortType,s.depthTexture.minFilter=e.NearestFilter,s.depthTexture.magFilter=e.NearestFilter),s}setupEventListeners(){window.addEventListener("resize",this.onResize),window.addEventListener("orientationchange",this.onResize),document.addEventListener("visibilitychange",this.onVisiblityChane)}stop(){this.running=!1,window.removeEventListener("resize",this.onResize),window.removeEventListener("orientationchange",this.onResize),document.removeEventListener("visibilitychange",this.onVisiblityChane),this.onLoopCallbacks=[],this.renderer.dispose(),this.depthRenderTarget.dispose(),this.csm.dispose(),this.container.replaceChildren()}onLoop(e){this.onLoopCallbacks.push(e)}removeOnLoop(e){const t=this.onLoopCallbacks.find(e);this.onLoopCallbacks.splice(t,1)}loop(r,s=!1){var n=C();n.showPanel(0);performance.now();e.Ray.prototype.intersectTriangle;let a=0;const o=new i,h=new i,d=e=>{var i,s;const l=this.renderer.getContext();if(this.paused&&this.running&&l.drawingBufferHeight>1)return void setTimeout((()=>d(e)),500);this.renderer.autoClear=!1,this.renderer.clear(),this.renderer.setViewport(0,0,this.container.clientWidth,this.container.clientHeight),this.camera,n.begin();let c=(e*=.001)-a;if(a=e,o.copy(this.camera.matrixWorld),c>1){let e=c;for(;e>.05;)r(T),e-=T;r(e)}else r(c);this.onLoopCallbacks.forEach((e=>e(c))),null===(i=this.camera)||void 0===i||i.updateMatrixWorld(),h.copy(this.camera.matrixWorld),h.equals(o)||(this.renderer.shadowMap.needsUpdate=!0),this.resizeRender();const m=[],g=[];if(this.scene.traverse((i=>{var r,s,n,a,o,h;i instanceof t&&i.visible&&((null===(s=null===(r=i.material)||void 0===r?void 0:r.userData)||void 0===s?void 0:s.water)||(null===(n=i.material)||void 0===n?void 0:n.uniforms)&&null!=(null===(a=i.material)||void 0===a?void 0:a.uniforms[u]))?(i.visible=!1,m.push(i),this.initDepthUniform(i.material),i.renderOrder=100):i instanceof p&&(i.visible=!1,g.push(i)),i instanceof t&&(null===(o=i.material)||void 0===o?void 0:o.uniforms)&&null!=(null===(h=i.material)||void 0===h?void 0:h.uniforms[x])&&(i.material.uniforms[x].value=e)})),m.length>0){if(this.scene.overrideMaterial=P,this.renderer.setRenderTarget(this.depthRenderTarget),!this.paused&&null!=this.camera)try{this.renderer.clear(),this.renderer.render(this.scene,this.camera)}catch(e){console.warn(e)}this.renderer.setRenderTarget(null),this.scene.overrideMaterial=null}m.forEach((e=>e.visible=!0)),g.forEach((e=>e.visible=!0));try{!this.paused&&this.running&&(this.composer.render(c),this.renderOverlay())}catch(e){console.warn(e)}n.end(),null===(s=this.csm)||void 0===s||s.update(),this.running&&(this.fpsCap?setTimeout((()=>{requestAnimationFrame(d)}),1e3/this.fpsCap):requestAnimationFrame(d))};requestAnimationFrame(d)}renderOverlay(){const e=Array.from(this.overlayCameras.values()).slice(0,this.maxInsetCameras),t=this.container.clientWidth/2,i=e.length*this.insetWidth+(e.length-1)*this.insetMargin;for(let r=0;r<e.length;r++)this.renderer.clearDepth(),this.renderer.setViewport(t-i/2+this.insetWidth*r+this.insetMargin*r,this.insetOffsetY,this.insetWidth,this.insetHeight),this.renderer.render(this.scene,e[r])}addOverlayCamera(e){this.overlayCameras.add(e)}clearOverlayCameras(){this.overlayCameras.clear()}removeOverlayCamera(e){this.overlayCameras.delete(e)}render(){this.composer.render()}initDepthUniform(e){e instanceof r&&(e.uniforms[u].value=this.isDepthTextureExtensionSupported?this.depthRenderTarget.depthTexture:this.depthRenderTarget.texture,null!=e.uniforms[g]&&e.uniforms[g].value.set(this.container.clientWidth*this.renderer.getPixelRatio(),this.container.clientHeight*this.renderer.getPixelRatio()),this.camera instanceof s&&(e.uniforms[f].value=this.camera.near,e.uniforms[w].value=this.camera.far))}}export function setRenderingPaused(e){var t,i;null!=(null===(i=null===(t=window.editor)||void 0===t?void 0:t.viewer)||void 0===i?void 0:i.renderingView)&&(window.editor.viewer.renderingView.paused=e)}const T=.05;
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/asset-resource-loader.d.ts

@@ -0,0 +1,32 @@
+import { Group, Texture } from 'three';
+import { Asset } from './model';
+import { CollisionShape } from './collision/collision-shape';
+export declare class AssetResourceLoader {
+    private basePath;
+    private cache;
+    private textureCache;
+    private loadingManager;
+    private glbLoader;
+    private fbxLoader;
+    private textureLoader;
+    private audioLoader;
+    private makeReady;
+    private ready;
+    constructor();
+    setDataDir(path: string): void;
+    private getUri;
+    getTexture(asset: Asset): Promise<Texture>;
+    getMesh(asset: Asset): Promise<LoadedMesh>;
+    getAudio(asset: Asset): Promise<AudioBuffer>;
+    private collisionShapeCache;
+    private computeCollisionShapes;
+    private loadMesh;
+    private loadByAsset;
+}
+export interface LoadedMesh {
+    scene: AssetMeshInstance;
+}
+export declare class AssetMeshInstance extends Group {
+    collisionShapes?: CollisionShape[];
+}
+export declare function getElectronArg(name: string): string;

package/dist/scene/asset-resource-loader.js

@@ -0,0 +1,5 @@
+import{__awaiter as e}from"tslib";import{AudioLoader as t,Group as i,LoadingManager as s,TextureLoader as o}from"three";import{GLTFLoader as r}from"three-stdlib";import{FBXLoader as n}from"three-stdlib";import{cloneMesh as a}from"../utils/mesh";import{pathJoin as h}from"../utils/files";import{Subject as l,firstValueFrom as d}from"rxjs";import{importCollisionShapes as c}from"./collision/collision-shape-import";const u=["glb","fbx"];export class AssetResourceLoader{constructor(){this.cache=new Map,this.textureCache=new Map,this.loadingManager=new s,this.glbLoader=new r(this.loadingManager),this.fbxLoader=new n(this.loadingManager),this.textureLoader=new o(this.loadingManager),this.audioLoader=new t(this.loadingManager),this.makeReady=new l,this.ready=d(this.makeReady),this.collisionShapeCache=new Map}setDataDir(e){this.basePath=h(e,"asset-resources"),this.makeReady.next(!0)}getUri(e){return h(this.basePath,e)+`?windowId=${getElectronArg("windowId")}`}getTexture(t){return e(this,void 0,void 0,(function*(){return null==t?null:(yield this.ready,this.cache.has(t.id)||(yield this.textureLoader.loadAsync(this.getUri(t.fileKey)).then((e=>(e.flipY=!1,this.textureCache.set(t.id,e),e)))),this.textureCache.get(t.id))}))}getMesh(t){var s;return e(this,void 0,void 0,(function*(){if(yield this.ready,!u.includes(null===(s=t.fileFormat)||void 0===s?void 0:s.toLowerCase()))return console.error("Unsupported mesh file format "+t.fileFormat,t),{scene:new i};this.cache.has(t.fileKey)||(yield this.loadMesh(t));const{scene:e}=this.cache.get(t.fileKey),o=this.computeCollisionShapes(t,e),r=(new AssetMeshInstance).copy(a(e));return r.collisionShapes=o,{scene:r}}))}getAudio(t){return e(this,void 0,void 0,(function*(){return yield this.ready,this.audioLoader.loadAsync(this.getUri(t.fileKey))}))}computeCollisionShapes(e,t){return this.collisionShapeCache.get(e.id)||this.collisionShapeCache.set(e.id,c(t)),this.collisionShapeCache.get(e.id)}loadMesh(t){return e(this,void 0,void 0,(function*(){return yield this.ready,yield this.loadByAsset(t).then((e=>(e.scene.animations=[],this.cache.set(t.fileKey,e),e)))}))}loadByAsset(e){const t=this.getUri(e.fileKey);switch(e.fileFormat){case"glb":return this.glbLoader.loadAsync(t).then((e=>({scene:e.scene})));case"fbx":return this.fbxLoader.loadAsync(t).then((e=>({scene:e})))}}}export class AssetMeshInstance extends i{}export function getElectronArg(e){var t;const i=`--${e}=`,s=null===(t=window.process)||void 0===t?void 0:t.argv.find((e=>e.startsWith(i)));return null==s?void 0:s.substring(i.length)}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/assets-provider.d.ts

@@ -0,0 +1,9 @@
+import { Subject } from "rxjs";
+import { Asset, AssetId } from "./model";
+export interface AssetsProvider {
+    onCreate: Subject<Asset>;
+    onDelete: Subject<Asset>;
+    onUpdate: Subject<Asset>;
+    getAsset(assetId: AssetId): Promise<Asset>;
+    getAssets(): Promise<Asset[]>;
+}

package/dist/scene/assets-provider.js

@@ -0,0 +1,5 @@
+export{};
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/bootstrap.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import { RenderingView } from '../rendering';
+import { AssetResourceLoader } from './asset-resource-loader';
+import { ActorProvider, SceneMaterializer } from './materializer';
+import { RuntimeBackendService } from './runtime-backend-service';
+import { RuntimeAssetsService } from './runtime-asset-service';
+import { ShaderType, ActorType } from '../shader/shader';
+export type ShaderDefinitions = {
+    [name: string]: ShaderType;
+};
+export type ActorDefinitions = {
+    [name: string]: ActorType;
+};
+export declare function loadScene(view: RenderingView, sceneName: string, dataDir: string, shaders: ShaderDefinitions, actors: ActorDefinitions, actorProvider: ActorProvider, backendService: RuntimeBackendService, assetsService: RuntimeAssetsService, assetResourceLoader: AssetResourceLoader): Promise<{
+    scene: THREE.Scene;
+    view: RenderingView;
+    materializer: SceneMaterializer;
+    assetResourceLoader: AssetResourceLoader;
+    assetsService: RuntimeAssetsService;
+    actors: import("../gameplay").BaseActor[];
+}>;

package/dist/scene/bootstrap.js

@@ -0,0 +1,5 @@
+import{__awaiter as e}from"tslib";import{polyfill as t}from"../utils/polyfill";import{SceneDataService as i}from"./scene-data-service";import{SceneMaterializer as n}from"./materializer";import{basicSceneSetup as r}from"./sky";export function loadScene(o,s,a,c,m,l,d,p,f){return e(this,void 0,void 0,(function*(){t();const{scene:e,renderer:a,camera:u}=o;r(e);const y=yield d.getScene(s);if(null==y)throw Error(`Could not find scene with name ${s}`);const v=yield d.getSceneData(y.id),w=new i;w.initiate(v,!0);const h=Object.entries(c).map((([e,t])=>({name:e,type:t}))),S=Object.entries(m).map((([e,t])=>({name:e,type:t}))),b=new n(e,w,p,f,o,h,S,l);return yield b.initWithInstancing(),{scene:e,view:o,materializer:b,assetResourceLoader:f,assetsService:p,actors:b.actorInstances}}))}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/collision/collision-shape-import.d.ts

@@ -0,0 +1,4 @@
+import { Object3D } from "three";
+import { CollisionShape } from "./collision-shape";
+export declare function importCollisionShapes(group: Object3D): CollisionShape[];
+export declare function isCollisionMesh(object: Object3D): boolean;

package/dist/scene/collision/collision-shape-import.js

@@ -0,0 +1,5 @@
+import{Box3 as e,Euler as t,Mesh as n,Quaternion as o,Vector3 as i}from"three";import{BoxCollisionShape as r,ConvexPolyhedronCollisionShape as s,SphereCollisionShape as a,TrimeshCollisionShape as m}from"./collision-shape";const c=new o;export function importCollisionShapes(o){const x=[];return o.traverse((o=>{if(o instanceof n||o.isMesh){const n=function(t){if(t.name.startsWith(u.convex))return new s(t);if(t.name.startsWith(u.box)){const n=t.clone();n.quaternion.set(0,0,0,1),n.updateMatrixWorld();const o=(new e).setFromObject(n);return isFinite(o.min.lengthSq())?new r(new i(o.max.x-o.min.x,o.max.y-o.min.y,o.max.z-o.min.z)):null}if(t.name.startsWith(u.sphere)){t.geometry.computeBoundingSphere();const e=t.geometry.boundingSphere.radius*Math.max(t.scale.x,t.scale.y,t.scale.z);return new a(e)}if(t.name.startsWith(u.trimesh))return new m(t.geometry);{t.geometry.computeBoundingBox();const e=function(e){const t=e.max.x-e.min.x,n=e.max.y-e.min.y,o=e.max.z-e.min.z;return t+n+o}(h.copy(t.geometry.boundingBox).applyMatrix4(t.matrixWorld));if(e>.001)return new s(t)}}(o);null!=n&&(n.offset=o.getWorldPosition(new i),n.rotation=(new t).setFromQuaternion(o.getWorldQuaternion(c)),x.push(n),isCollisionMesh(o)&&(o.visible=!1))}})),x}export function isCollisionMesh(e){return e.name.startsWith(u.convex)||e.name.startsWith(u.box)||e.name.startsWith(u.sphere)||e.name.startsWith(u.trimesh)}var u;!function(e){e.convex="UCX_",e.box="UBX_",e.sphere="USP_",e.trimesh="UTM_"}(u||(u={}));const h=new e;
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/collision/collision-shape.d.ts

@@ -0,0 +1,59 @@
+import { BoxGeometry, BufferGeometry, Euler, Material, Mesh, Vector3 } from "three";
+export declare class CollisionShape {
+    offset: Vector3;
+    rotation: Euler;
+    withOffset(vector: Vector3): this;
+    withRotation(rotation: Euler): this;
+}
+export declare class BoxCollisionShape extends CollisionShape {
+    readonly dimensions: Vector3;
+    constructor(dimensions: Vector3);
+}
+export declare class PlaneCollisionShape extends CollisionShape {
+    readonly width: number;
+    readonly height: number;
+    constructor(width: number, height: number);
+}
+export declare class SphereCollisionShape extends CollisionShape {
+    readonly radius: number;
+    constructor(radius: number);
+}
+export declare class CylinderCollisionShape extends CollisionShape {
+    readonly radiusTop: number;
+    readonly radiusBottom: number;
+    readonly height: number;
+    readonly segments: number;
+    readonly orentation: Euler;
+    constructor(radiusTop: number, radiusBottom: number, height: number, segments: number, orentation: Euler);
+}
+export declare class ConeCollisionShape extends CollisionShape {
+    readonly radiusBottom: number;
+    readonly height: number;
+    constructor(radiusBottom: number, height: number);
+}
+export declare class ConvexPolyhedronCollisionShape extends CollisionShape {
+    readonly mesh: Mesh | BufferGeometry;
+    constructor(mesh: Mesh | BufferGeometry);
+}
+export declare class TrimeshCollisionShape extends CollisionShape {
+    readonly geometry: BufferGeometry;
+    constructor(geometry: BufferGeometry);
+}
+export declare class MeshCollisionShape extends CollisionShape {
+    readonly geometry: BufferGeometry;
+    constructor(geometry: BufferGeometry);
+}
+export declare class CapsuleCollisionShape extends CollisionShape {
+    length: number;
+    radius: number;
+    constructor(length: number, radius: number);
+}
+export declare class PhysicalShapeMesh extends Mesh {
+    collisionShape: CollisionShape;
+    isPhysicalShapeMesh: boolean;
+    constructor(geometry: BufferGeometry, material: Material, collisionShape: CollisionShape);
+}
+export declare class PhysicalBoxMesh extends PhysicalShapeMesh {
+    isPhysicalBoxMesh: boolean;
+    constructor(geometry: BoxGeometry, material: Material);
+}

package/dist/scene/collision/collision-shape.js

@@ -0,0 +1,5 @@
+import{Euler as s,Mesh as e,Vector3 as o}from"three";export class CollisionShape{constructor(){this.offset=new o,this.rotation=new s}withOffset(s){return this.offset.copy(s),this}withRotation(s){return this.rotation.copy(s),this}}export class BoxCollisionShape extends CollisionShape{constructor(s){super(),this.dimensions=s}}export class PlaneCollisionShape extends CollisionShape{constructor(s,e){super(),this.width=s,this.height=e}}export class SphereCollisionShape extends CollisionShape{constructor(s){super(),this.radius=s}}export class CylinderCollisionShape extends CollisionShape{constructor(s,e,o,t,i){super(),this.radiusTop=s,this.radiusBottom=e,this.height=o,this.segments=t,this.orentation=i}}export class ConeCollisionShape extends CollisionShape{constructor(s,e){super(),this.radiusBottom=s,this.height=e}}export class ConvexPolyhedronCollisionShape extends CollisionShape{constructor(s){super(),this.mesh=s}}export class TrimeshCollisionShape extends CollisionShape{constructor(s){super(),this.geometry=s}}export class MeshCollisionShape extends CollisionShape{constructor(s){super(),this.geometry=s}}export class CapsuleCollisionShape extends CollisionShape{constructor(s,e){super(),this.length=s,this.radius=e}}export class PhysicalShapeMesh extends e{constructor(s,e,o){super(s,e),this.collisionShape=o,this.isPhysicalShapeMesh=!0}}export class PhysicalBoxMesh extends PhysicalShapeMesh{constructor(s,e){super(s,e,new BoxCollisionShape(new o(s.parameters.width,s.parameters.height,s.parameters.depth))),this.isPhysicalBoxMesh=!0}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/landscape/landscape-manager.d.ts

@@ -0,0 +1,43 @@
+import { SceneObject } from '../../scene/materializer';
+import { RenderingView } from '../../rendering';
+import { Mesh, Vector3 } from 'three';
+import { LandscapeGroup } from './landscape';
+import { AssetResourceLoader } from '../asset-resource-loader';
+import { AssetsProvider } from '../../scene/assets-provider';
+import { ShaderImpl } from '../../shader/shader';
+/**
+ * Creates landscape with varying level of detail depending on the
+ */
+export declare class LandscapeManager {
+    readonly source: SceneObject;
+    private view;
+    private landscape;
+    private assetManagerService;
+    private assetService;
+    private shaders;
+    private applyMaterial;
+    private scatterMeshes;
+    private loadedScatterSquares;
+    private refreshRequests;
+    private defaultLandscapeMaterial;
+    private onLoopHandler;
+    constructor(source: SceneObject, view: RenderingView, landscape: LandscapeGroup, assetManagerService: AssetResourceLoader, assetService: AssetsProvider, shaders: ShaderImpl[], applyMaterial: (object: Mesh) => void);
+    updateShaders(shaders: ShaderImpl[]): void;
+    private sectionCache;
+    private grassGeometry;
+    private grassMaterial;
+    private loadGrass;
+    refreshGeometry(): void;
+    private applyHeightMap;
+    private deleteOldScatterMeshes;
+    private _matrix;
+    queueRefreshScatter(origin: Vector3, force?: boolean, predicate?: (mesh: Mesh) => boolean): void;
+    private scatterGeometryCache;
+    refreshScatter(origin: Vector3, force?: boolean, predicate?: (mesh: Mesh) => boolean): Promise<void>;
+    stop(): void;
+    private _lastUpdatePosition;
+    private _cameraPosition;
+    private update;
+    clear(): void;
+    private createLandscapeMesh;
+}

package/dist/scene/landscape/landscape-manager.js

@@ -0,0 +1,5 @@
+import{__awaiter as e}from"tslib";import{materialFromAsset as t}from"../../scene/materializer";import{Mesh as s,PlaneGeometry as o,Vector3 as n,InstancedMesh as i,Matrix4 as a,MeshLambertMaterial as r,Color as c,Vector2 as l,Triangle as h,Box3 as u,MathUtils as d,MeshStandardMaterial as f,ShaderMaterial as m,DoubleSide as p,PerspectiveCamera as w}from"three";import{indexBy as y}from"../../utils/collections";import{smoothNormalsCrossMeshes as v}from"./utils";import*as M from"three";import{defaultLandscapeMaterial as g,LandscapeMesh as x}from"./landscape";import{meanVectors3withWeight as S,clamp as b}from"../../utils/math";import{whenIdle as A}from"../../utils/async";import{Subject as P,debounceTime as z}from"rxjs";new n,new n;const L=new n,B=new n,G=new n;export class LandscapeManager{constructor(e,t,s,o,i,r,c){this.source=e,this.view=t,this.landscape=s,this.assetManagerService=o,this.assetService=i,this.shaders=r,this.applyMaterial=c,this.scatterMeshes=new Map,this.loadedScatterSquares=new Set,this.refreshRequests=new P,this.defaultLandscapeMaterial=g.clone(),this.onLoopHandler=()=>this.update(),this.sectionCache=new Map,this._matrix=new a,this.scatterGeometryCache=new Map,this._lastUpdatePosition=new n,this._cameraPosition=new n,this.view.onLoop(this.onLoopHandler),this.defaultLandscapeMaterial.color=g.color,this.refreshRequests.pipe(z(500)).subscribe((e=>this.refreshScatter(e.origin,e.force,e.predicate)))}updateShaders(e){this.shaders=e}loadGrass(){return e(this,void 0,void 0,(function*(){const e=yield this.assetService.getAsset("6ij937n72g");yield this.assetManagerService.getMesh(e);this.grassGeometry=new o(2,2,3,3);const t=this.grassGeometry.getAttribute("normal");for(let e=0;e<t.count;e++)t.setXYZ(e,0,1,0);t.needsUpdate=!0,this.grassMaterial=new f({color:3765785})}))}refreshGeometry(){const e=this.source.landscape.options,t=(new n,new n);this.view.camera.getWorldPosition(t);const s=[];G.fromArray(this.source.position);const o=this.view.camera instanceof w?Math.min(this.view.camera.far,1e3):1e3,i=1.1*o,a=e.sections.y*e.sectionSize/-2,r=e.sections.x*e.sectionSize/-2;for(let n=0;n<e.sections.x;n++)if(L.x=r+n*e.sectionSize,!(Math.abs(t.x-L.x)>i))for(let c=0;c<e.sections.y;c++){L.z=a+c*e.sectionSize,B.copy(G).add(L);const l=B.distanceTo(t),h=`${n},${c}`,u=this.landscape.sections.find((e=>e.x===n&&e.y===c));if(l<=o){if(null==u){this.sectionCache.has(h)||this.sectionCache.set(h,this.createLandscapeMesh(this.source,e,r,a,n,c));const t=this.sectionCache.get(h);this.applyMaterial(t),this.landscape.add(t),s.push(t)}}else l>i&&this.landscape.remove(u)}v(s)}applyHeightMap(e,t,s,o=1){var n,i,a,r;const c=Math.pow(s+1,2),l=e.getAttribute("position"),h=y(null!==(n=t.points)&&void 0!==n?n:[],(e=>e.i));if(1===o)for(const e of t.points)l.setY(e.i,e.y);else for(let e=0;e<l.count;e++){const t=$(e,l.count,c);let s=0;s=t%1==0?null!==(a=null===(i=h.get(t))||void 0===i?void 0:i.y)&&void 0!==a?a:0:Math.floor(null===(r=h.get(t))||void 0===r?void 0:r.y),l.setY(e,s)}l.needsUpdate=!0,e.computeVertexNormals()}deleteOldScatterMeshes(){var e,t;const s=new Set;for(const[o,n]of null!==(t=null===(e=this.source.grass)||void 0===e?void 0:e.layers.entries())&&void 0!==t?t:[])for(const[e,t]of n.meshes.entries()){const t=`${o}-${e}`;s.add(t)}for(const e of this.scatterMeshes.keys())if(!s.has(e)){this.scatterMeshes.get(e).forEach((e=>{var t;null===(t=e.parent)||void 0===t||t.remove(e),e.dispose()})),this.scatterMeshes.delete(e)}}queueRefreshScatter(e,t=!1,s=(()=>!0)){this.refreshRequests.next({origin:e,force:t,predicate:s})}refreshScatter(a,l=!1,u=(()=>!0)){var f,w,v,g;return e(this,void 0,void 0,(function*(){l&&this.scatterGeometryCache.clear(),this.deleteOldScatterMeshes();for(const[x,P]of null!==(w=null===(f=this.source.grass)||void 0===f?void 0:f.layers.entries())&&void 0!==w?w:[])for(const[f,w]of P.meshes.entries()){const P=`${x}-${f}`;this.scatterMeshes.has(P)||this.scatterMeshes.set(P,new Map);const z=this.scatterMeshes.get(P),L=yield this.assetService.getAsset(w.assetId),B=yield this.assetManagerService.getMesh(L),G=[];if(B.scene.traverse((e=>{e instanceof s&&G.push(e)})),1!==G.length){console.log(B),console.warn("Dynamic grass only works for meshes with a single geometry.");continue}if(!(G[0]instanceof s)){console.warn("Only meshes can be used for dynamic grass. Found:",B.scene);continue}const $=G[0];let _=$.geometry;this.scatterGeometryCache.has($.geometry.uuid)?_=this.scatterGeometryCache.get($.geometry.uuid):(_=$.geometry.clone(),!0===w.normalsUp&&E(_),this.scatterGeometryCache.set($.geometry.uuid,_),null==_.userData.updatedMatrix&&(B.scene.updateMatrixWorld(),_.applyMatrix4($.matrixWorld),_.userData.updatedMatrix=!0));const U=_.getIndex().count/3;if(U>400){console.warn(`The triangle count of ${L.name} is too big ${U}. Keep it below 400`);continue}const D=null!=L.materialAssignments&&L.materialAssignments.length>0?L.materialAssignments[0].materialId:null,I=null!=D&&"null"!==D?yield t(yield this.assetService.getAsset(D),null,this.assetService,this.assetManagerService,this.shaders,!1):null;let O=null!=I?I:$.material;O instanceof m&&(O.side=p);const Y=d.degToRad(null!==(v=w.maxSlope)&&void 0!==v?v:90),X=Math.cos(Y),F=this.landscape.sections,N=F.filter(k(a,w.viewDistance)).filter((e=>!z.has(e.uuid)||l)).filter((e=>u(e)));F.filter(C(a,2*w.viewDistance)).forEach((e=>{var t;const s=z.get(e.uuid);null===(t=null==s?void 0:s.parent)||void 0===t||t.remove(s),z.delete(e.uuid)}));performance.now();const Z=this.source.landscape.options,K=Z.sectionSize,V=null!==(g=w.density)&&void 0!==g?g:1,J=null!=V?V:1,Q=Z.density,ee=K/Q,te=J,se=ee/Math.sqrt(te),oe=Math.pow(Q,2),ne=se/ee,ie=Math.floor(oe*te),ae=[0,0,0];for(const t of N)yield A((()=>e(this,void 0,void 0,(function*(){var e,s,a,u,d,f,m;t.updateWorldMatrix(!0,!1);const p=this._matrix,v=new n,g=t.geometry.getAttribute("position"),A=t.geometry.getAttribute("normal"),P=(null!==(e=this.source.vertexMaterials)&&void 0!==e?e:[]).filter((e=>e.m===t.name)),L=y(P,(e=>e.i));let B=z.get(t.uuid);if(null==B||B.count==ie&&!l||(null===(s=B.parent)||void 0===s||s.remove(B),z.delete(t.uuid),B=null),null==B){const e=new o(.15,.75).getAttribute("normal");for(let t=0;t<e.count;t++);new r({color:new c(3765785),side:M.DoubleSide});B=new i(_,O,ie),B.raycast=()=>{},B.receiveShadow=!0}const G=new h(new n,new n,new n);let[$,C,k,U]=[new n,new n,new n,new n],[D,I,Y]=[[],[],[]],[E,F,N]=[new n,new n,new n,new n];const Z=new n,K=new n,V=new n,J=new n,ee=new h(new n,new n,new n),re=new h(new n,new n,new n),ce=new h(new n,new n,new n),le=new h(new n,new n,new n);let he=0;e:for(let e=0;e<oe;e++){const s=Math.floor(e/Q);$.fromBufferAttribute(g,e+s),J.copy($).applyMatrix4(t.matrixWorld),ee.a.copy($),ee.b.fromBufferAttribute(g,e+1+s),ee.c.fromBufferAttribute(g,e+Q+1+s),re.a.copy(ee.b),re.b.copy(ee.c),re.c.fromBufferAttribute(g,e+Q+2+s),ce.a.fromBufferAttribute(A,e+s),ce.b.fromBufferAttribute(A,e+1+s),ce.c.fromBufferAttribute(A,e+Q+1+s),le.a.copy(ce.b),le.b.copy(ce.c),le.c.fromBufferAttribute(A,e+Q+2+s);const o=[];o[0]=null===(a=L.get(e+s))||void 0===a?void 0:a.w,o[1]=null===(u=L.get(e+1+s))||void 0===u?void 0:u.w,o[2]=null===(d=L.get(e+Q+1+s))||void 0===d?void 0:d.w,o[3]=null===(f=L.get(e+Q+2+s))||void 0===f?void 0:f.w;let n=0;for(let e=0;e<1;e+=ne)for(let s=0;s<1;s+=ne){if(he>ie)break e;if(n++,n>te)continue e;1-e>s?(C=ee.a,k=ee.b,U=ee.c,E=ce.a,F=ce.b,N=ce.c,D=o[0],I=o[1],Y=o[2]):(C=re.a,k=re.b,U=re.c,E=le.a,F=le.b,N=le.c,D=o[1],I=o[2],Y=o[3]),G.a.copy(C),G.b.copy(k),G.c.copy(U),q(G),Z.set($.x,0,$.z);const i=1.5;Z.x+=(2*Math.random()-1)*i*se,Z.z+=(2*Math.random()-1)*i*se,G.getBarycoord(Z,v).toArray(ae);if(R([D,I,Y],ae,.2)!==x-1)continue;const a=[C,k,U];S(a,ae,K),S([E,F,N],ae,V);const r=a.map((e=>e.y)),c=Math.max(...r),l=Math.min(...r);if(K.y=b(K.y,l,c),null!=w.maxSlope&&w.maxSlope<90&&V.y<X)continue;const h=K.applyMatrix4(t.matrixWorld);h.y+=T(w.offsetMin,w.offsetMax);const u=T(w.scaleMin,w.scaleMax);p.makeScale(1,1,1),p.setPosition(h),p.scale(W(u)),w.alignToNormal&&H(p,h,B.matrixWorld,V),!1!==w.randomRotation&&j(p),B.setMatrixAt(he,p),he++}}B.instanceMatrix.count=he,p.makeScale(0,0,0);for(let e=he;e<ie;e++)B.setMatrixAt(e,p);B.instanceMatrix.needsUpdate=!0,z.has(t.uuid)||null===(m=this.landscape)||void 0===m||m.attach(B),z.set(t.uuid,B)}))));performance.now()}}))}stop(){this.view.removeOnLoop(this.onLoopHandler)}update(){this.view.camera&&(this.view.camera.getWorldPosition(this._cameraPosition),this._cameraPosition.distanceTo(this._lastUpdatePosition)>10&&(this._lastUpdatePosition.copy(this._cameraPosition),this.refreshGeometry(),this.refreshScatter(this._cameraPosition)))}clear(){this.scatterMeshes.forEach((e=>e.forEach((e=>{var t;return null===(t=e.parent)||void 0===t?void 0:t.remove(e)}))))}createLandscapeMesh(e,t,s,n,i,a){const r=new o(t.sectionSize,t.sectionSize,t.density,t.density);r.rotateX(Math.PI/-2);const c=this.defaultLandscapeMaterial,l=new x(r,c);l.position.x=s+i*t.sectionSize,l.position.z=n+a*t.sectionSize,l.receiveShadow=!0,l.castShadow=!1,l.userData.landscape={x:i,y:a},l.x=i,l.y=a,l.name=`${i},${a}`;const h=e.landscape.heightMaps.find((e=>e.x===i&&e.y===a));return null!=h&&this.applyHeightMap(r,h,t.density,1),r.computeBoundsTree(),l}}function $(e,t,s){const o=Math.sqrt(t),n=Math.floor(e/o)/(o-1),i=e%o/(o-1),a=Math.sqrt(s);return(s-1)*n-(a-1)*n+(a-1)*i}new Map,new l(0,0),new l(1,0),new l(0,1),new l(1,0),new l(0,1),new l(1,1),new n;const _=new u;function C(e,t){return function(s){return _.setFromObject(s).distanceToPoint(e)>t}}function k(e,t){return function(s){return _.setFromObject(s).distanceToPoint(e)<t}}function q(e){e.a.y=0,e.b.y=0,e.c.y=0}function R(e,t,s=.5){let o=-1,n=0;for(let i=0;i<e.length;i++)if(null!=e[i])for(let a=0;a<e[i].length;a++){const r=e[i][a]*t[i];r>s&&r>n&&(n=r,o=a)}return o}function T(e,t){let s=t-e,o=Math.random();return o*=s,o+=e,o}const U=new n;function W(e){return U.set(e,e,e)}new n;const D=new n,I=new n(0,1,0),O=(new a).makeRotationX(Math.PI/-2);function H(e,t,s,o){e.lookAt(D,o,I).multiply(O)}const Y=new a;function j(e){e.multiply(Y.makeRotationY(Math.random()*Math.PI/2))}function E(e){const t=e.getAttribute("normal");for(let e=0;e<t.count;e++)t.setXYZ(e,0,1,0);t.needsUpdate=!0}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/landscape/landscape.d.ts

@@ -0,0 +1,20 @@
+import { Group, Mesh } from 'three';
+import { NodeShaderMaterial } from "three-shader-graph";
+export interface LandscapeInitOptions {
+    sectionSize: number;
+    sections: {
+        x: number;
+        y: number;
+    };
+    density: number;
+}
+export declare function initLandscape(opts: LandscapeInitOptions): LandscapeGroup;
+export declare function createLandscapeDefaultMaterial(): NodeShaderMaterial;
+export declare const defaultLandscapeMaterial: NodeShaderMaterial;
+export declare class LandscapeMesh extends Mesh {
+    x: number;
+    y: number;
+}
+export declare class LandscapeGroup extends Group {
+    get sections(): LandscapeMesh[];
+}

package/dist/scene/landscape/landscape.js

@@ -0,0 +1,5 @@
+import{Group as e,Mesh as a}from"three";import{Color as r}from"three";import{varyingAttributes as t,float as o,mod as s,dot as n,vec2 as c,step as i,fract as l,mix as p,rgb as d,NodeShaderMaterial as u,rgba as m,standardMaterial as f}from"three-shader-graph";import{mixColorsByLayer as h,select as x}from"../../shader-nodes";export function initLandscape(e){e.sections.y,e.sectionSize,e.sections.x,e.sectionSize;return new LandscapeGroup}export function createLandscapeDefaultMaterial(){const e=t.uv,a=o(10),x=o(7),L=s(n(c(1,1),i(c(.5,.5),l(e.multiplyScalar(a)))),o(2)),y=s(n(c(1,1),i(c(.5,.5),l(e.multiplyScalar(x.multiply(a))))),o(2)),M=p(d(4473924),d(5592405),L),S=p(M,M.addScalar(o(.1)),y),D=h({layerColors:[m(S).rgb(),...["#55DDE0","#33658A","#2F4858"].map((e=>d(e))).reverse()],enableNoise:!1}),g=new u({color:f({color:D})});return g.color=new r("#aaaaaa"),g}export const defaultLandscapeMaterial=createLandscapeDefaultMaterial();export class LandscapeMesh extends a{}export class LandscapeGroup extends e{get sections(){return this.children.filter((e=>e instanceof LandscapeMesh))}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/landscape/utils.d.ts

@@ -0,0 +1,9 @@
+import { Mesh } from 'three';
+import { LandscapeMesh } from './landscape';
+export declare function smoothNormalsCrossMeshes(meshes: LandscapeMesh[]): void;
+export declare class SectionGrid {
+    private grid;
+    constructor(meshes: LandscapeMesh[]);
+    find(x: number, y: number): Mesh | null;
+}
+export declare function onEdge(i: number, count: number): boolean;

package/dist/scene/landscape/utils.js

@@ -0,0 +1,5 @@
+import{Vector3 as e}from"three";export function smoothNormalsCrossMeshes(t){const r=new SectionGrid(t);performance.now();const n=new e,o=new e,i=new e,s=new e;for(const e of t){const t=e.geometry.getAttribute("position"),c=e.geometry.getAttribute("normal");for(const d of f(t.count)){const{otherMesh:f,j:a}=u(d,t.count,e,r,o);if(null==f)continue;n.fromBufferAttribute(t,d),n.applyMatrix4(e.matrixWorld);const x=f.geometry.getAttribute("position"),h=f.geometry.getAttribute("normal");f.updateMatrixWorld(),o.fromBufferAttribute(x,a),o.applyMatrix4(f.matrixWorld),i.fromBufferAttribute(c,d),s.fromBufferAttribute(h,a);const l=i.add(s).divideScalar(2);c.setXYZ(d,l.x,l.y,l.z),h.setXYZ(a,l.x,l.y,l.z),c.needsUpdate=!0,h.needsUpdate=!0;const m=(t.getY(d)+x.getY(a))/2;t.setY(d,m),x.setY(a,m)}}performance.now()}export class SectionGrid{constructor(e){this.grid=new Map;for(const t of e){const{x:e,y:r}=t;this.grid.has(e)||this.grid.set(e,new Map),this.grid.get(e).set(r,t)}}find(e,t){var r;return null===(r=this.grid.get(e))||void 0===r?void 0:r.get(t)}}const t={meshPredicate:(e,t)=>e.find(t.x,t.y-1),vertexFunc:(e,t)=>e+t*(t-1)},r={meshPredicate:(e,t)=>e.find(t.x-1,t.y-1),vertexFunc:(e,t)=>t*t-1},n={meshPredicate:(e,t)=>e.find(t.x+1,t.y-1),vertexFunc:(e,t)=>t*t-t},o={meshPredicate:(e,t)=>e.find(t.x,t.y+1),vertexFunc:(e,t)=>e-t*(t-1)},i={meshPredicate:(e,t)=>e.find(t.x-1,t.y+1),vertexFunc:(e,t)=>t-1},s={meshPredicate:(e,t)=>e.find(t.x+1,t.y+1),vertexFunc:(e,t)=>0},c={meshPredicate:(e,t)=>e.find(t.x-1,t.y),vertexFunc:(e,t)=>e+t-1},d={meshPredicate:(e,t)=>e.find(t.x+1,t.y),vertexFunc:(e,t)=>e-t+1};function u(e,u,f,a,x){const h=Math.sqrt(u),l=(e+1)%h==0,m=e%h==0;let y;if(e<h?(y=t,m&&(y=r),l&&(y=n)):e>=u-h?(y=o,m?y=i:l&&(y=s)):m?y=c:l&&(y=d),null==y)return{otherMesh:null,j:null};return{otherMesh:y.meshPredicate(a,f),j:y.vertexFunc(e,h)}}function*f(e){const t=Math.sqrt(e);for(let r=0;r<t;r++)yield r,yield r+e-t;for(let e=1,r=t-1;e<r;e++)yield e*t,yield e*t+t-1}export function onEdge(e,t){const r=Math.sqrt(t);return e<r||e%r==0||e>=t-r||(e+1)%r==0}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/scene/materializer.d.ts

@@ -0,0 +1,245 @@
+import { Subject } from "rxjs";
+import { Euler, Material, Object3D, Scene, Vector3 } from "three";
+import { GameComponent } from "../game-component/game-component";
+import { RenderingView } from "../rendering";
+import { ParameterType, PropertyParameter } from "../shader/parameter";
+import { ShaderImpl, ActorImpl } from '../shader/shader';
+import { Type } from "../utils/type";
+import { AssetResourceLoader } from './asset-resource-loader';
+import { AssetsProvider } from "./assets-provider";
+import { LandscapeInitOptions } from "./landscape/landscape";
+import { Asset, CustomParamValue, MaterialAssignment, ShapeType } from "./model";
+import { BaseActor } from '../gameplay/actors/actor';
+import { ContainerInstance } from "typedi";
+export type SceneObjectId = string;
+export type SceneObjectType = "asset_mesh" | "light" | "shape_mesh" | "spline" | "landscape" | "particles" | "global_fog" | "global_light" | "actor" | "group" | "prefab";
+export type LightType = "point" | "directional" | "ambient";
+type DirectionalLightSettings = {
+    color: string | number;
+    intensity: number;
+    direction: number[];
+    castShadow: boolean;
+};
+type PointLightSettings = {
+    color: string | number;
+    intensity: number;
+    distance: number;
+    decay: number;
+    castShadow: boolean;
+};
+type AmbientLightSettings = {
+    color: string | number;
+    intensity: number;
+};
+export interface SceneObject {
+    id: SceneObjectId;
+    name?: string;
+    children?: SceneObject[];
+    assetId?: string;
+    shape?: ShapeType;
+    shapeParams?: Record<string, CustomParamValue>;
+    light?: {
+        type: 'point';
+        point: PointLightSettings;
+    } | {
+        type: 'directional';
+        directional: DirectionalLightSettings;
+    } | {
+        type: 'ambient';
+        ambient: AmbientLightSettings;
+    };
+    position: number[];
+    scale: number[];
+    rotation: any[];
+    collisionDetection: boolean;
+    components?: AttachedComponent[];
+    hidden?: boolean;
+    materialAssignments?: MaterialAssignment[];
+    vertexMaterials?: VertexMaterial[];
+    fog?: FogSettings;
+    landscape?: LandscapeData;
+    grass?: GrassSettings;
+    actor?: ActorSettings;
+    type: SceneObjectType;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+}
+export interface ActorSettings {
+    type: string;
+    params?: Record<string, CustomParamValue>;
+    innerParams?: {
+        path: string[];
+        params: Record<string, CustomParamValue>;
+    }[];
+}
+export interface GrassSettings {
+    layers: GrassLayer[];
+}
+export interface GrassLayer {
+    meshes: GrassMesh[];
+}
+export interface GrassMesh {
+    assetId: string;
+    viewDistance: number;
+    density: number;
+    sparseNoiseThreshold: number;
+    sparseNoiseScale: number;
+    alignToNormal: boolean;
+    maxSlope: number;
+    randomRotation: boolean;
+    normalsUp: boolean;
+    scaleMin: number;
+    scaleMax: number;
+    offsetMin: number;
+    offsetMax: number;
+}
+export type FogType = "linear" | "density";
+export interface FogSettings {
+    type: FogType;
+    color: string;
+    near?: number;
+    far?: number;
+    density?: number;
+}
+export interface LandscapeData {
+    options: LandscapeInitOptions;
+    heightMaps: HeighMapSection[];
+}
+export interface HeighMapSection {
+    x: number;
+    y: number;
+    points: HeigtMapPoint[];
+}
+export interface HeigtMapPoint {
+    i: number;
+    y: number;
+}
+export interface VertexMaterial {
+    m?: string;
+    i: number;
+    w: number[];
+}
+export interface AttachedComponent {
+    path: string;
+    className: string;
+    name: string;
+    params: {
+        name: string;
+        value: any;
+    }[];
+}
+export interface SceneDataProvider {
+    getObjects(): SceneObject[];
+    onUpdate(callback: (sceneObject: SceneObject) => void): any;
+    onRemove(callback: (sceneObject: SceneObject) => void): any;
+}
+export declare const shapeDefaultColor = "#aaaaaa";
+export declare class SceneMaterializerLoader {
+    private dataProvider;
+    private assetsService;
+    private assetManagerService;
+    constructor(dataProvider: SceneDataProvider, assetsService: AssetsProvider, assetManagerService: AssetResourceLoader);
+    get(scene: Scene, renderingView: RenderingView): SceneMaterializer;
+}
+export interface ActorProvider<A = BaseActor> {
+    create<T extends BaseActor>(type: Type<T>, position?: Vector3, rotation?: Euler, delayInit?: boolean): Promise<T>;
+    initActor(actor: A): Promise<void>;
+}
+/**
+ * Reads scene data and subscribes to added objects to it to update the scene with Three.js objects
+ */
+export declare class SceneMaterializer {
+    private scene;
+    private dataProvider;
+    private assetsService;
+    private assetManagerService;
+    private renderingView;
+    private shaders;
+    private actorTypes;
+    private actorProvider;
+    private objectMap;
+    private sceneObjectMap;
+    private updateSubscription;
+    readonly components: GameComponent[];
+    private readonly landscapeManagers;
+    materializedActors: Map<string, BaseActor>;
+    inEditor: boolean;
+    updated$: Subject<{
+        object: Object3D;
+        source: SceneObject;
+    }>;
+    removed$: Subject<{
+        object: Object3D;
+        source: SceneObject;
+    }>;
+    error$: Subject<Error>;
+    private editorActorParamSnapshot;
+    private originalFog;
+    constructor(scene: Scene, dataProvider: SceneDataProvider, assetsService: AssetsProvider, assetManagerService: AssetResourceLoader, renderingView: RenderingView, shaders: ShaderImpl[], actorTypes: ActorImpl[], actorProvider: ActorProvider);
+    get actorInstances(): BaseActor[];
+    private prefetchAssets;
+    init(): Promise<void>;
+    /**
+     * Actors are initialized after first created during materialization because
+     * they need to exist to be able to refer to each other.
+     * While topolical ordering of materialization could allow referencing
+     * each other, it would not support circular references which
+     * is however possible if
+     * The value this added complexity brings is that it is possible
+     * to access another actor in the onInit method of an actor.
+     * This should however be discouraged as it may not be initialised,
+     * especially if there is a circular dependency in which case that would
+     * be impossible to guarantee.
+     */
+    private initActorsPostInit;
+    private applyActorComponentParams;
+    private _canBeInstancedCache;
+    private canAssetBeInstanced;
+    initWithInstancing(): Promise<void>;
+    private createInstancedMesh;
+    private remove;
+    private deleteSceneObject;
+    private findByAssetId;
+    private applyMaterials;
+    private _originalMaterials;
+    private applyMaterial;
+    private unapplyMaterials;
+    updateActors(actors: ActorImpl[]): void;
+    updateShaders(shaders: ShaderImpl[]): void;
+    private update;
+    private materializeAndInitActor;
+    private findParent;
+    private fixFogColor;
+    private findMeshWithGeometry;
+    private applyVertexMaterials;
+    /**
+     * @param source Data used to describe the object
+     * @param parent The object the materialized object should be spatially relative to
+     * @param anonymous If the object should be possible to select and edit
+     * @returns
+     */
+    materialize(source: SceneObject, parent?: Object3D, anonymous?: boolean): Promise<Object3D>;
+    private createComponent;
+    private createFromActor;
+    cleanup(): void;
+    private createFromShape;
+    private createLandscape;
+    private applyHeightMaps;
+    private createMeshByShape;
+    private createFromAsset;
+    private createFromPrefabAsset;
+    private createParticleSystem;
+    private createLight;
+    private applyDirectionalAmbientLight;
+    private applyDirectionalLight;
+    dispose(): void;
+}
+export declare function materialFromAsset(asset: Asset, renderingView: RenderingView, assetsService: AssetsProvider, assetManagerService: AssetResourceLoader, shaders: ShaderImpl[], useCache?: boolean): Promise<Material>;
+export declare function prepareCustomParams<T>(propertyParams: PropertyParameter[], previous: Record<string, CustomParamValue>, defaults?: Record<string, unknown>): Record<string, CustomParamValue>;
+export declare function prepareCustomParamsFromType<T>(type: Type<T>, previous: Record<string, CustomParamValue>, diContainer?: ContainerInstance): Record<string, CustomParamValue>;
+/**
+ * Returns a serialized version of a custom parameter's value.
+ * Returns undefined if
+ */
+export declare function serializeCustomParameter(type: ParameterType, value: unknown): unknown;
+export {};