run-scene-v2 0.1.136 → 0.1.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "run-scene-v2",
-  "version": "0.1.136",
+  "version": "0.1.140",
   "description": "",
   "main": "./build/index.js",
   "dependencies": {

package/types/index.d.ts

@@ -1,6 +1,7 @@
 import { TransformControls } from "run-scene-core/examples/jsm/controls/TransformControls";
 import RunScene, { Utils, ModelEx, MaterialEx, TextureEx, Bus } from "./src/RunScene";
 import Three from "./src/Libs/Three";
+export { textureAdapt } from "./src/Texture/utils/TextureAdapt";
 declare const _default: {
     RunScene: typeof RunScene;
     Utils: typeof Utils;

package/types/src/Assets/Assets.d.ts

@@ -33,7 +33,7 @@ export default class Assets {
         scene: import("run-scene-core").Scene;
         camera: import("run-scene-core").PerspectiveCamera;
         renderer: import("run-scene-core").WebGLRenderer;
-        controls: import("run-scene-core/examples/jsm/controls/OrbitControls").OrbitControls;
+        controls: import("../Controls/ConstrainedOrbitControls").ConstrainedOrbitControls;
         engineDom: HTMLElement;
         render2: CSS3DRenderer;
         render3: CSS3DRenderer;

package/types/src/CallBack/CallBack.d.ts

@@ -275,7 +275,7 @@ export default class OptionCb extends BaseEx {
         }, any>;
         onSetInfo: BindEvent<{
             model: any;
-            type: "material" | "lock" | "visible" | "v3" | "receiveShadow" | "castShadow";
+            type: "material" | "visible" | "lock" | "v3" | "receiveShadow" | "castShadow";
             data: any;
         }, void>;
     };
@@ -520,6 +520,11 @@ export default class OptionCb extends BaseEx {
                     map: MapEx<string, E.Texture>;
                     opts: ExporterGltfType["opts"];
                 }, Promise<any>>;
+                bindBlob: BindEvent<void, Promise<{
+                    data: Blob;
+                    uniqueName: string;
+                    config: Record<string, any>;
+                }[]>>;
             };
             model: {
                 parse: BindEvent<{
@@ -575,6 +580,11 @@ export default class OptionCb extends BaseEx {
                     [key: string]: ArrayBuffer;
                 };
             }, void>;
+            onLoadedBindBlob: BindEvent<{
+                config: Record<string, any>;
+                uniqueName: string;
+                ab: ArrayBuffer;
+            }, void>;
         };
     };
     custom: {
@@ -652,7 +662,7 @@ export default class OptionCb extends BaseEx {
                 animaUpdateCbs: (() => void)[];
                 completedCbs: (() => void)[];
             };
-            ignoreModules?: ("texture" | "scene" | "material" | "light" | "model" | "sky" | "time-line")[];
+            ignoreModules?: ("texture" | "scene" | "material" | "model" | "light" | "sky" | "time-line")[];
         }, void>;
         resetItem: BindEvent<{
             type: string;
@@ -773,6 +783,20 @@ export default class OptionCb extends BaseEx {
                 };
             }, void>;
         };
+        background: {
+            layerSet: BindEvent<{
+                layerId: number;
+                layer: any;
+            }, void>;
+            layerRemove: BindEvent<{
+                layerId: number;
+            }, void>;
+            layerUpdate: BindEvent<{
+                layerId: number;
+                property: string;
+                value: any;
+            }, void>;
+        };
     };
     msg: {
         add: BindEvent<{

package/types/src/Camera/Background.d.ts

@@ -0,0 +1,47 @@
+import MapEx from "../Ex/MapEx";
+import RunScene from "../RunScene";
+import { E } from "../Types/Engine";
+export interface BackgroundLayer {
+    id: number;
+    source: Blob | null;
+    texture: E.Texture | null;
+    type: "image" | "video";
+    opacity: number;
+    visible: boolean;
+    zIndex: number;
+    dom: HTMLElement | null;
+    url?: string;
+}
+export interface LayerOptions {
+    opacity?: number;
+    visible?: boolean;
+    zIndex?: number;
+}
+export default class CameraBackground {
+    runScene: RunScene;
+    layers: MapEx<number, BackgroundLayer>;
+    container: HTMLElement | null;
+    catchMap: Array<any>;
+    constructor(runScene: RunScene);
+    init(): void;
+    private initBindArraybuffer;
+    private initContainer;
+    setLayer(layerId: number, source: Blob | null, options?: LayerOptions): Promise<BackgroundLayer>;
+    private createLayer;
+    private createLayerDom;
+    private detectSourceType;
+    private setImageLayer;
+    private setVideoLayer;
+    removeLayer(layerId: number): void;
+    clearAll(): void;
+    getLayer(layerId: number): BackgroundLayer | null;
+    setOpacity(layerId: number, opacity: number): void;
+    setVisible(layerId: number, visible: boolean): void;
+    setZIndex(layerId: number, zIndex: number): void;
+    swapLayers(layerId1: number, layerId2: number): void;
+    setSize(width: number, height: number): void;
+    private disposeLayer;
+    dispose(): void;
+    toJSON(): object;
+    fromJSON(data: any): void;
+}

package/types/src/CameraEx.d.ts

@@ -1,5 +1,6 @@
 import { OrthographicCamera, PerspectiveCamera } from "run-scene-core";
 import CameraConfig from "./Camera/Config";
+import CameraBackground from "./Camera/Background";
 import MapEx from "./Ex/MapEx";
 import RunScene from "./RunScene";
 import { E } from "./Types/Engine";
@@ -23,6 +24,7 @@ export default class EngineCamera {
     oCam: OrthographicCamera;
     pCam: any;
     config: CameraConfig;
+    backgroundEx: CameraBackground;
     constructor(runScene: RunScene);
     onInited: () => void;
     clean: () => void;
@@ -127,6 +129,7 @@ export default class EngineCamera {
             far: number;
             fov: number;
         }>;
+        background: object;
     };
     getDistanceSelectModel(model?: E.Model): number;
 }

package/types/src/Code.d.ts

@@ -27,7 +27,7 @@ export default class Code {
             scene: Three.Scene;
             camera: Three.PerspectiveCamera;
             renderer: Three.WebGLRenderer;
-            controls: import("run-scene-core/examples/jsm/controls/OrbitControls").OrbitControls;
+            controls: import("./Controls/ConstrainedOrbitControls").ConstrainedOrbitControls;
             engineDom: HTMLElement;
             render2: import("run-scene-core/examples/jsm/renderers/CSS3DRenderer").CSS3DRenderer;
             render3: import("run-scene-core/examples/jsm/renderers/CSS3DRenderer").CSS3DRenderer;

package/types/src/Const/constModel.d.ts

@@ -1,4 +1,4 @@
-export declare const defModelNames: readonly ["Group", "Box", "Plane", "Sphere", "Sprite", "VerticesRain", "Water", "3DDom", "3DSprite", "2DDom", "GroundProjected", "Lod", "RandomTree", "FluffyGrass", "Atmosphere", "Text"];
+export declare const defModelNames: readonly ["Group", "Box", "Plane", "Sphere", "Sprite", "VerticesRain", "Water", "3DDom", "3DSprite", "2DDom", "GroundProjected", "Lod", "RandomTree", "FluffyGrass", "Atmosphere", "WindField", "Text"];
 export declare const commonModelNames: readonly ["Group", "Box", "Plane", "Sprite", "VerticesRain", "Water", "GroundProjected", "3DDom", "3DSprite", "2DDom"];
 export declare const constModelNameForDom: readonly ["3DDom", "3DSprite", "2DDom"];
 export declare const exModelNames: readonly ["test", "Text"];

package/types/src/Const/constRunScene.d.ts

@@ -1,7 +1,8 @@
-export declare const version = "0.1.136";
+export declare const version = "0.1.140";
 export declare const versionStr: string;
 import "./constStr";
 import "./constAssets";
 export declare const defExt = ".lt";
+export declare const defCompressExt = ".ltc";
 export declare const defFileName = "linktwins.lt";
 export declare const sliceBufferStr = "_||_";

package/types/src/Exporter/GLTFExporter/ExporterGltf.d.ts

@@ -75,6 +75,9 @@ export declare type ExportJSONEx = {
     };
     msg?: string;
     isDecodeCompress?: boolean;
+    exporterOptions?: {
+        notPp?: boolean;
+    };
 };
 export declare type ExportJSONExNotOption = {
     [P in keyof ExportJSONEx]-?: ExportJSONEx[P];
@@ -112,7 +115,7 @@ export default class ExporterGltf extends BaseEx {
     scene(down?: boolean, type?: "scene" | "main-scene" | "sub-scene", opts?: ExporterGltfType["opts"]): Promise<ArrayBuffer>;
     originModel(model?: E.Model): Promise<void>;
     addDecoderToAb(ab: ArrayBuffer, downLoad?: boolean): Promise<Blob>;
-    addInfoToAb(outMap: Obj, moduleMap?: Obj): Blob;
+    addInfoToAb(outMap: Obj, moduleMap?: Obj): Promise<Blob>;
     addNormalToAb(ab: ArrayBuffer, opts?: {
         toArrayBuffer?: boolean;
     }): Promise<any>;

package/types/src/FileEx/FileEx.d.ts

@@ -8,6 +8,7 @@ export declare type filExParse = {
     type: "model" | "scene" | "material" | "timeLine" | "texture" | "timeLineData" | "graph" | "camera" | "texture-other";
     result: any;
     file?: File;
+    json?: any;
 };
 export default class FileEx {
     runScene: RunScene;

package/types/src/Graph/GraphBase.d.ts

@@ -341,6 +341,7 @@ export default abstract class GraphBase extends LGraphNode {
     drawMessage(ctx: CanvasRenderingContext2D): void;
     drawRoundRect(ctx: CanvasRenderingContext2D, r: number, x: number, y: number, w: number, h: number): void;
     hasSubNode(type: "input" | "out", name: string): boolean;
+    getIns(): Graph;
     log(any: string, parms?: GraphBaseType["triggerParms"]): void;
     findOutNodeByName(name: string): GraphBase[];
     onLoadProperties(map: Obj): void;

package/types/src/Graph/Nodes/Texture/TextureVideoState.d.ts

@@ -0,0 +1,9 @@
+import GraphBase, { GraphBaseType } from "../../GraphBase";
+export default class TextureVideoState extends GraphBase {
+    title: string;
+    static title: string;
+    constructor();
+    actions: string[];
+    onPlay(_runName: string, parms: GraphBaseType["triggerParms"]): void;
+    onStop(): void;
+}

package/types/src/Material/MaterialUtils.d.ts

@@ -16,3 +16,9 @@ export declare const getMaterialMapNameByModel: (model: E.unknowModel, each?: (c
     material: E.Material;
     model: E.unknowModel;
 }>;
+export declare const utilsMaterial: {
+    useByListBackUndos: (_material: E.Material, _list: {
+        name: string;
+        url: string;
+    }[]) => void;
+};

package/types/src/ModelEx/ModelExDef/ModelExDef.d.ts

@@ -9,6 +9,7 @@ import WaterModel from "./WaterModel";
 import { RandomTree } from "./RandomTree";
 import { FluffyGrass } from "./FluffyGrass";
 import Atmosphere from "./Atmosphere";
+import WindField from "./WindField";
 export declare type ModelExDefType = {
     tools: {
         type: string;
@@ -28,6 +29,7 @@ export default class ModelExDef {
     lod: Lod;
     fluffyGrass: FluffyGrass;
     atmosphere: Atmosphere;
+    windField: WindField;
     models: string[];
     constructor(runScene: RunScene);
     createSavedModel(type: DefModelTypes): any;

package/types/src/ModelEx/ModelExDef/WindField.d.ts

@@ -0,0 +1,57 @@
+import RunScene from "../../RunScene";
+import { ParamsConfigManager } from "../../Config/ParamsConfig";
+import { E } from "../../Types/Engine";
+import { HelperBeforeModel } from "./BeforeModel";
+import { Obj } from "js-funcs";
+import { TypeModelBase } from "./ModelBaseType";
+export default class WindField implements HelperBeforeModel {
+    isHelperBeforeModel: boolean;
+    runScene: RunScene;
+    models: any[];
+    paramsConfig: ParamsConfigManager<unknown>;
+    static paramsConfig: ParamsConfigManager<unknown>;
+    static type: string;
+    type: string;
+    private windFields;
+    private windPlanes;
+    private lbmBuffers;
+    private lbmComputeMaterial;
+    private lbmRenderMaterial;
+    private computeGeometry;
+    private computeScene;
+    private computeCamera;
+    constructor(runScene: RunScene);
+    dispose(): void;
+    private initializeLBMCompute;
+    private createLBMComputeMaterial;
+    private createLBMRenderMaterial;
+    private updateModel;
+    private createLBMBuffers;
+    private initializeLBMTexture;
+    private performLBMStep;
+    private debugVelocityField;
+    private updateObstacles;
+    private updateObstacleData;
+    private isDescendant;
+    private getBounds;
+    create(map?: {
+        oldParams?: Obj;
+    }): any;
+    private createWindFieldModel;
+    private createLBMPlane;
+    private createWindPlane;
+    private initializeWindField;
+    private updateWindFieldConfig;
+    private updateWindPlaneVisualization;
+    private updateBoundsConfig;
+    private updateWindPlaneConfig;
+    to(model: E.unknowModel): void;
+    toNormal: (map: {
+        type: string;
+        model: E.unknowModel;
+        runScene: RunScene;
+    }) => {
+        model: any;
+    };
+    parse: (map: TypeModelBase["process"]) => any[];
+}

package/types/src/OptionsEx.d.ts

@@ -124,6 +124,7 @@ export declare class OptionsEx {
         compressTexture: boolean;
         notMaterial: boolean;
         outTime: number;
+        notPp: boolean;
     };
     stats: Stats | undefined;
     runScene: RunScene;

package/types/src/Snapshot/Snapshot.d.ts

@@ -7,7 +7,7 @@ import { SnapshotType } from "./SnapshotType";
 export { ConstantSnapshot };
 export default class Snapshot {
     runScene: RunScene;
-    sliceMap: MapEx<"texture" | "scene" | "material" | "light" | "model" | "sky" | "time-line", {
+    sliceMap: MapEx<"texture" | "scene" | "material" | "model" | "light" | "sky" | "time-line", {
         [is: string]: MapEx<string, {
             name: string;
             time: number;

package/types/src/Texture/TextureEx.d.ts

@@ -76,7 +76,9 @@ export default class EngineTexture {
     clone(oldTexture: E.Texture): E.Texture;
     getDef(img?: ImageBitmap): Texture;
     private getSameAndAddtoAll;
-    afterLoad(texture: E.Texture, blob?: Blob): Promise<Texture>;
+    afterLoad(texture: E.Texture, blob?: Blob, opts?: {
+        md5?: boolean;
+    }): Promise<Texture>;
     getSameTexture(md5: string, oldTexture: E.Texture): E.Texture | undefined;
     initTextureAndAddtoAll(texture: E.Texture): Promise<Texture>;
     addTextureToAll(texture: E.Texture): void;
@@ -87,6 +89,7 @@ export default class EngineTexture {
     coverByImage(texture: E.Texture, file: File | null | E.Texture, opts?: {
         addUndo?: boolean;
     }): Promise<UndoBase[]>;
+    setTextureEncodeing(texture: E.Texture, opts: string): void;
     remove(texture: E.Texture | E.Texture[]): Promise<void>;
     delete(texture: E.Texture): void;
     setAnima: (m: {
@@ -102,7 +105,9 @@ export default class EngineTexture {
     getSize(texture: E.Texture): number;
     setEncoding(encoding: "def" | "srgb"): void;
     getAllBase64ByType(_type: "id"): {};
-    createByImg(img: ImageBitmap | ImageData, blob?: Blob): Promise<Texture>;
+    createByImg(img: ImageBitmap | ImageData, blob?: Blob, opts?: {
+        md5?: boolean;
+    }): Promise<Texture>;
     bindDataForTexture(t: E.Texture, newT: E.Texture): void;
     awaitOuterToImgBitMapMap: MapEx<string, boolean>;
     toStandard(texture: E.Texture): Promise<{

package/types/src/Texture/TextureUtils.d.ts

@@ -62,7 +62,9 @@ export declare const disposeTexture: (texture: E.Texture | null) => void;
 export declare const setTextureBlob: (texture: Texture, blob: Blob) => void;
 export declare const setTextureSize: (texture: Texture) => void;
 export declare const setTextureUrl: (texture: Texture, blob: Blob) => void;
-export declare const bindTextureBaseData: (texture: E.Texture, _runScene: RunScene, inputBlob?: Blob) => Promise<Texture>;
+export declare const bindTextureBaseData: (texture: E.Texture, _runScene: RunScene, inputBlob?: Blob, opts?: {
+    md5?: boolean;
+}) => Promise<Texture>;
 export declare const getBlobByTexture: (texture: E.Texture) => any;
 export declare const initTexture: (texture: E.Texture) => Texture;
 export declare const parseImageBitMapByBlob: (blob: ImageBitmapSource, map?: TextureExType["loadOptions"]) => Promise<ImageBitmap>;

package/types/src/Texture/utils/TextureAdapt.d.ts

@@ -0,0 +1,9 @@
+import { Texture } from "run-scene-core";
+export default class TextureAdapt {
+    processVideoTexture(blob: Blob): Promise<Texture>;
+    bindVideoTexture(texture: any): boolean;
+    isVideoTexture(texture: any): any;
+    bindVideoToObj(obj: any): boolean;
+    isVideoObj(obj: any): any;
+}
+export declare const textureAdapt: TextureAdapt;

package/types/src/Types/Engine.d.ts

@@ -1,7 +1,7 @@
 import { Obj } from "js-funcs";
 import { Euler, Object3D, Vector2, Vector3 } from "run-scene-core";
-import { OrbitControls } from "run-scene-core/examples/jsm/controls/OrbitControls";
 import * as THREE from "run-scene-core";
+import { ConstrainedOrbitControls } from "../Controls/ConstrainedOrbitControls";
 export interface UserData {
     isTimeLineUsed: boolean | undefined;
     id: string;
@@ -28,7 +28,7 @@ export declare namespace E {
     type BaseMaterialTexture = "map" | "metalnessMap" | "roughnessMap" | "normalMap" | "aoMap" | "emissiveMap" | "alphaMap" | "lightMap" | "envMap" | "displacementMap";
     type Camera = THREE.PerspectiveCamera;
     type Scene = THREE.Scene;
-    type Controls = OrbitControls;
+    type Controls = ConstrainedOrbitControls;
     type Texture = THREE.Texture;
     type Render = THREE.WebGLRenderer;
 }