@zephyr3d/scene 0.1.0

package/dist/app.js

@@ -0,0 +1,173 @@
+import { InputManager } from './input/inputmgr.js';
+import { makeEventTarget } from '@zephyr3d/base';
+
+/**
+ * Event that will be fired every frame
+ *
+ * @remarks
+ * This is where all the rendering work is done.
+ *
+ * @public
+ */ class AppTickEvent {
+    type = 'tick';
+}
+/**
+ * This event will be fired whenever the device size changes
+ * @public
+ */ class AppResizeEvent {
+    width;
+    height;
+    type;
+    constructor(width, height){
+        this.type = 'resize';
+        this.width = width;
+        this.height = height;
+    }
+}
+/**
+ * Application class
+ *
+ * @remarks
+ * This is the entry point of your application.
+ * The Application is responsible for initializing the rendering device
+ * and doing the rendering loop.
+ * The Application can not be created more than once. You can get the
+ * instance by calling the 'Application.instance' static method.
+ *
+ * @public
+ */ class Application extends makeEventTarget(Object)() {
+    _options;
+    _device;
+    _inputManager;
+    _running;
+    _ready;
+    _canRender;
+    _drawEvent;
+    _logger;
+    _elapsed;
+    static _instance;
+    /**
+   * Creates an instance of Application
+   * @param opt - The creation options
+   */ constructor(opt){
+        super();
+        if (Application._instance) {
+            throw new Error('It is not allowed to have multiple Application instances');
+        }
+        Application._instance = this;
+        this._options = {
+            backend: opt.backend,
+            enableMSAA: opt.enableMSAA ?? false,
+            pixelRatio: opt.pixelRatio ?? window.devicePixelRatio ?? 1,
+            canvas: opt.canvas
+        };
+        this._inputManager = new InputManager(this);
+        this._running = null;
+        this._ready = false;
+        this._canRender = false;
+        this._elapsed = 0;
+        this._drawEvent = new AppTickEvent();
+        this._logger = {
+            log (text, mode) {
+                if (mode === 'warn') {
+                    console.warn(text);
+                } else if (mode === 'error') {
+                    console.error(text);
+                } else if (mode === 'debug') {
+                    console.debug(text);
+                } else if (mode === 'info') {
+                    console.info(text);
+                } else {
+                    console.log(text);
+                }
+            }
+        };
+    }
+    /** The input manager instance */ get inputManager() {
+        return this._inputManager;
+    }
+    /** The options that was used to create the application */ get options() {
+        return this._options;
+    }
+    /**
+   * Query if the device is ok to render objects now.
+   *
+   * @remarks
+   * False will be returned if the device is lost.
+   */ get canRender() {
+        return this._canRender;
+    }
+    /**
+   * Query time elapsed since last frame in seconds
+   */ get timeElapsedInSeconds() {
+        return this._elapsed;
+    }
+    /** Gets the singleton instance of the application */ static get instance() {
+        return this._instance;
+    }
+    /** The rendering device that was initialized by the application */ get device() {
+        return this._device;
+    }
+    /** Gets the device type */ get deviceType() {
+        return this._options.backend.typeName();
+    }
+    /** The logger object */ get logger() {
+        return this._logger;
+    }
+    set logger(val) {
+        this._logger = val;
+    }
+    /** Set focus */ focus() {
+        this._device.canvas.focus();
+    }
+    /** Wait until the application is ready. */ async ready() {
+        if (!this._ready) {
+            this._device = await this._options.backend.createDevice(this._options.canvas, {
+                dpr: this._options.pixelRatio,
+                msaa: !!this._options.enableMSAA
+            });
+            if (!this._device) {
+                throw new Error('App.init(): create device failed');
+            }
+            this._device.canvas.focus();
+            this._inputManager.start();
+            this._device.on('resize', (ev)=>{
+                this.dispatchEvent(new AppResizeEvent(ev.width, ev.height));
+            });
+            this._ready = true;
+        }
+    }
+    /** Render one frame */ frame() {
+        if (this._ready) {
+            this._canRender = this.device.beginFrame();
+            this._elapsed = this.device.frameInfo.elapsedFrame * 0.001;
+            this.device.setFramebuffer(null);
+            this.device.setViewport(null);
+            this.device.setScissor(null);
+            this.dispatchEvent(this._drawEvent);
+            this.device.endFrame();
+        }
+    }
+    /** Start running the rendering loop */ run() {
+        if (this._running) {
+            return;
+        }
+        const that = this;
+        (function entry() {
+            that._running = requestAnimationFrame(entry);
+            that.frame();
+        })();
+    }
+    /** Stop running the rendering loop */ stop() {
+        if (this._running) {
+            cancelAnimationFrame(this._running);
+            this._running = null;
+        }
+    }
+    /** Message log */ log(text, mode) {
+        this._logger?.log(text, mode);
+    }
+}
+
+export { AppResizeEvent, AppTickEvent, Application };
+//# sourceMappingURL=app.js.map

package/dist/app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/asset/assetmanager.js

@@ -0,0 +1,476 @@
+import { HttpRequest, isPowerOf2, nextPowerOf2, Vector3 } from '@zephyr3d/base';
+import { GLTFLoader } from './loaders/gltf/gltf_loader.js';
+import { WebImageLoader } from './loaders/image/webimage_loader.js';
+import { DDSLoader } from './loaders/dds/dds_loader.js';
+import { HDRLoader } from './loaders/hdr/hdr.js';
+import { SceneNode } from '../scene/scene_node.js';
+import { Mesh } from '../scene/mesh.js';
+import { AnimationClip } from '../animation/animation.js';
+import { AnimationSet } from '../animation/animationset.js';
+import { TranslationTrack } from '../animation/translationtrack.js';
+import { RotationTrack } from '../animation/rotationtrack.js';
+import '../animation/eulerrotationtrack.js';
+import { ScaleTrack } from '../animation/scaletrack.js';
+import { Skeleton } from '../animation/skeleton.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { Application } from '../app.js';
+import '../shaders/framework.js';
+import '@zephyr3d/device';
+import { CopyBlitter } from '../blitter/copy.js';
+import { getSheenLutLoader, getTestCubemapLoader } from './builtin.js';
+import { GraphNode } from '../scene/graph_node.js';
+import { BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BUILTIN_ASSET_TEST_CUBEMAP } from '../values.js';
+import { TGALoader } from './loaders/image/tga_Loader.js';
+
+/**
+ * The asset manager
+ * @public
+ */ class AssetManager {
+    /** @internal */ static _builtinTextures = {};
+    /** @internal */ static _builtinTextureLoaders = {
+        [BUILTIN_ASSET_TEXTURE_SHEEN_LUT]: getSheenLutLoader(64),
+        [BUILTIN_ASSET_TEST_CUBEMAP]: getTestCubemapLoader()
+    };
+    /** @internal */ _httpRequest;
+    /** @internal */ _textureLoaders;
+    /** @internal */ _modelLoaders;
+    /** @internal */ _textures;
+    /** @internal */ _models;
+    /** @internal */ _binaryDatas;
+    /** @internal */ _textDatas;
+    /**
+   * Creates an instance of AssetManager
+   */ constructor(){
+        this._httpRequest = new HttpRequest();
+        this._textureLoaders = [
+            new WebImageLoader(),
+            new DDSLoader(),
+            new HDRLoader(),
+            new TGALoader()
+        ];
+        this._modelLoaders = [
+            new GLTFLoader()
+        ];
+        this._textures = {};
+        this._models = {};
+        this._binaryDatas = {};
+        this._textDatas = {};
+    }
+    /**
+   * HttpRequest instance of the asset manager
+   */ get httpRequest() {
+        return this._httpRequest;
+    }
+    /**
+   * Removes all cached assets
+   */ clearCache() {
+        this._textures = {};
+        this._models = {};
+        this._binaryDatas = {};
+        this._textDatas = {};
+    }
+    /**
+   * Adds a texture loader to the asset manager
+   *
+   * @remarks
+   * TODO: this should be a static method
+   *
+   * @param loader - The texture loader to be added
+   */ addTextureLoader(loader) {
+        if (loader) {
+            this._textureLoaders.unshift(loader);
+        }
+    }
+    /**
+   * Adds a model loader to the asset manager
+   *
+   * @remarks
+   * TODO: this should be a static method
+   *
+   * @param loader - The model loader to be added
+   */ addModelLoader(loader) {
+        if (loader) {
+            this._modelLoaders.unshift(loader);
+        }
+    }
+    /**
+   * Fetches a text resource from a given URL
+   * @param url - The URL from where to fetch the resource
+   * @returns The fetched text
+   */ async fetchTextData(url) {
+        let P = this._textDatas[url];
+        if (!P) {
+            P = this.loadTextData(url);
+            this._textDatas[url] = P;
+        }
+        return P;
+    }
+    /**
+   * Fetches a binary resource from a given URL
+   * @param url - The URL from where to fetch the resource
+   * @returns
+   */ async fetchBinaryData(url) {
+        let P = this._binaryDatas[url];
+        if (!P) {
+            P = this.loadBinaryData(url);
+            this._binaryDatas[url] = P;
+        }
+        return P;
+    }
+    /**
+   * Fetches a texture resource from a given URL
+   * @param url - The URL from where to fetch the resource
+   * @param options - Options for texture fetching
+   * @returns The fetched texture
+   */ async fetchTexture(url, options) {
+        if (options?.texture) {
+            return this.loadTexture(url, options.mimeType ?? null, !options.linearColorSpace, options.samplerOptions, options.texture);
+        } else {
+            const hash = this.getHash('2d', url, options);
+            let P = this._textures[hash];
+            if (!P) {
+                P = this.loadTexture(url, options?.mimeType ?? null, !options?.linearColorSpace, options?.samplerOptions);
+                this._textures[hash] = P;
+            } else {
+                const tex = await P;
+                if (tex.disposed) {
+                    await tex.reload();
+                    return tex;
+                }
+            }
+            return P;
+        }
+    }
+    /** @internal */ async fetchModelData(scene, url, mimeType) {
+        let P = this._models[url];
+        if (!P) {
+            P = this.loadModel(url, mimeType);
+            this._models[url] = P;
+        }
+        return P;
+    }
+    /**
+   * Fetches a model resource from a given URL and adds it to a scene
+   * @param scene - The scene to which the model node belongs
+   * @param url - The URL from where to fetch the resource
+   * @param mimeType - The MIME type of the model resource
+   * @returns The created model node
+   */ async fetchModel(scene, url, mimeType) {
+        const sharedModel = await this.fetchModelData(scene, url, mimeType);
+        return this.createSceneNode(scene, sharedModel);
+    }
+    /** @internal */ async loadTextData(url) {
+        return this._httpRequest.requestText(url);
+    }
+    /** @internal */ async loadBinaryData(url) {
+        return this._httpRequest.requestArrayBuffer(url);
+    }
+    /** @internal */ async loadTexture(url, mimeType, srgb, samplerOptions, texture) {
+        const data = await this._httpRequest.requestArrayBuffer(url);
+        let ext = '';
+        let filename = '';
+        const dataUriMatchResult = url.match(/^data:([^;]+)/);
+        if (dataUriMatchResult) {
+            mimeType = mimeType || dataUriMatchResult[1];
+        } else {
+            filename = new URL(url, new URL(location.href).origin).pathname.split('/').filter((val)=>!!val).slice(-1)[0];
+            const p = filename ? filename.lastIndexOf('.') : -1;
+            ext = p >= 0 ? filename.substring(p).toLowerCase() : null;
+            if (!mimeType) {
+                if (ext === '.jpg' || ext === '.jpeg') {
+                    mimeType = 'image/jpg';
+                } else if (ext === '.png') {
+                    mimeType = 'image/png';
+                }
+            }
+        }
+        for (const loader of this._textureLoaders){
+            if ((!ext || !loader.supportExtension(ext)) && (!mimeType || !loader.supportMIMEType(mimeType))) {
+                continue;
+            }
+            const tex = await this.doLoadTexture(loader, filename, mimeType, data, !!srgb, samplerOptions, texture);
+            tex.name = filename;
+            if (url.match(/^blob:/)) {
+                tex.restoreHandler = async (tex)=>{
+                    await this.doLoadTexture(loader, filename, mimeType, data, !!srgb, samplerOptions, tex);
+                };
+            } else {
+                const so = samplerOptions ? null : {
+                    ...samplerOptions
+                };
+                tex.restoreHandler = async (tex)=>{
+                    await this.loadTexture(url, mimeType, srgb, so, tex);
+                };
+            }
+            return tex;
+        }
+        throw new Error(`Can not find loader for asset ${url}`);
+    }
+    /** @internal */ async doLoadTexture(loader, url, mimeType, data, srgb, samplerOptions, texture) {
+        const device = Application.instance.device;
+        if (device.type !== 'webgl') {
+            return await loader.load(this, url, mimeType, data, srgb, samplerOptions, texture);
+        } else {
+            let tex = await loader.load(this, url, mimeType, data, srgb, samplerOptions);
+            if (texture) {
+                const magFilter = tex.width !== texture.width || tex.height !== texture.height ? 'linear' : 'nearest';
+                const minFilter = magFilter;
+                const mipFilter = 'none';
+                const sampler = device.createSampler({
+                    addressU: 'clamp',
+                    addressV: 'clamp',
+                    magFilter,
+                    minFilter,
+                    mipFilter
+                });
+                const blitter = new CopyBlitter();
+                blitter.blit(tex, texture, sampler);
+                tex = texture;
+            } else {
+                const po2_w = isPowerOf2(tex.width);
+                const po2_h = isPowerOf2(tex.height);
+                const srgb = tex.isSRGBFormat();
+                if (srgb || !po2_w || !po2_h) {
+                    const newWidth = po2_w ? tex.width : nextPowerOf2(tex.width);
+                    const newHeight = po2_h ? tex.height : nextPowerOf2(tex.height);
+                    const magFilter = newWidth !== tex.width || newHeight !== tex.height ? 'linear' : 'nearest';
+                    const minFilter = magFilter;
+                    const mipFilter = 'none';
+                    const sampler = device.createSampler({
+                        addressU: 'clamp',
+                        addressV: 'clamp',
+                        magFilter,
+                        minFilter,
+                        mipFilter
+                    });
+                    const destFormat = srgb ? 'rgba8unorm' : tex.format;
+                    const blitter = new CopyBlitter();
+                    const newTexture = tex.isTexture2D() ? device.createTexture2D(destFormat, newWidth, newHeight) : device.createCubeTexture(destFormat, newWidth);
+                    blitter.blit(tex, newTexture, sampler);
+                    tex.dispose();
+                    tex = newTexture;
+                }
+            }
+            return tex;
+        }
+    }
+    /** @internal */ async loadModel(url, mimeType, name) {
+        const data = await this.httpRequest.requestBlob(url);
+        const filename = new URL(url, new URL(location.href).origin).pathname.split('/').filter((val)=>!!val).slice(-1)[0];
+        const p = filename ? filename.lastIndexOf('.') : -1;
+        const ext = p >= 0 ? filename.substring(p) : null;
+        for (const loader of this._modelLoaders){
+            if (!loader.supportExtension(ext) && !loader.supportMIMEType(mimeType || data.type)) {
+                continue;
+            }
+            const model = await loader.load(this, url, mimeType || data.type, data);
+            if (!model) {
+                throw new Error(`Load asset failed: ${url}`);
+            }
+            model.name = name || filename;
+            return model;
+        }
+        throw new Error(`Can not find loader for asset ${url}`);
+    }
+    /**
+   * Fetches a built-in texture
+   * @param name - Name of the built-in texture
+   * @returns The built-in texture
+   */ async fetchBuiltinTexture(name, texture) {
+        const loader = AssetManager._builtinTextureLoaders[name];
+        if (!loader) {
+            throw new Error(`Unknown builtin texture name: ${name}`);
+        }
+        if (texture) {
+            return loader(this, texture);
+        } else {
+            let P = AssetManager._builtinTextures[name];
+            if (!P) {
+                P = loader(this);
+                AssetManager._builtinTextures[name] = P;
+            }
+            const tex = await P;
+            tex.restoreHandler = async (tex)=>{
+                await loader(this, tex);
+            };
+            return tex;
+        }
+    }
+    /** @internal */ createSceneNode(scene, model, sceneIndex) {
+        const group = new SceneNode(scene);
+        group.name = model.name;
+        let animationSet = new AnimationSet(scene);
+        for(let i = 0; i < model.scenes.length; i++){
+            if (typeof sceneIndex === 'number' && sceneIndex >= 0 && i !== sceneIndex) {
+                continue;
+            } else if ((sceneIndex === undefined || sceneIndex === null) && model.activeScene >= 0 && i !== model.activeScene) {
+                continue;
+            }
+            const assetScene = model.scenes[i];
+            const skeletonMeshMap = new Map();
+            const nodeMap = new Map();
+            for(let k = 0; k < assetScene.rootNodes.length; k++){
+                this.setAssetNodeToSceneNode(scene, group, model, assetScene.rootNodes[k], skeletonMeshMap, nodeMap);
+            }
+            for (const animationData of model.animations){
+                const animation = new AnimationClip(animationData.name, group);
+                animationSet.add(animation);
+                for (const track of animationData.tracks){
+                    if (track.type === 'translation') {
+                        animation.addTrack(nodeMap.get(track.node), new TranslationTrack(track.interpolator));
+                    } else if (track.type === 'scale') {
+                        animation.addTrack(nodeMap.get(track.node), new ScaleTrack(track.interpolator));
+                    } else if (track.type === 'rotation') {
+                        animation.addTrack(nodeMap.get(track.node), new RotationTrack(track.interpolator));
+                    } else {
+                        throw new Error(`Could not load model: invalid animation track type: ${track.type}`);
+                    }
+                }
+                for (const sk of animationData.skeletons){
+                    const nodes = skeletonMeshMap.get(sk);
+                    if (nodes) {
+                        const skeleton = new Skeleton(sk.joints.map((val)=>nodeMap.get(val)), sk.inverseBindMatrices, sk.bindPoseMatrices);
+                        skeleton.updateJointMatrices();
+                        animation.addSkeleton(skeleton, nodes.mesh, nodes.bounding.map((val)=>this.getBoundingInfo(skeleton, val)));
+                    }
+                }
+                animation.stop();
+            }
+        }
+        if (animationSet.numAnimations === 0) {
+            animationSet.dispose();
+            animationSet = null;
+        }
+        return {
+            group,
+            animationSet
+        };
+    }
+    /**
+   * Sets the loader for a given builtin-texture
+   * @param name - Name of the builtin texture
+   * @param loader - Loader for the builtin texture
+   */ static setBuiltinTextureLoader(name, loader) {
+        if (loader) {
+            this._builtinTextureLoaders[name] = loader;
+        } else {
+            delete this._builtinTextureLoaders[name];
+        }
+    }
+    /** @internal */ getBoundingInfo(skeleton, meshData) {
+        const indices = [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0
+        ];
+        let minx = Number.MAX_VALUE;
+        let maxx = -Number.MAX_VALUE;
+        let miny = Number.MAX_VALUE;
+        let maxy = -Number.MAX_VALUE;
+        let minz = Number.MAX_VALUE;
+        let maxz = -Number.MAX_VALUE;
+        const v = meshData.rawPositions;
+        const vert = new Vector3();
+        const tmpV0 = new Vector3();
+        const tmpV1 = new Vector3();
+        const tmpV2 = new Vector3();
+        const tmpV3 = new Vector3();
+        const numVertices = Math.floor(v.length / 3);
+        for(let i = 0; i < numVertices; i++){
+            vert.setXYZ(v[i * 3], v[i * 3 + 1], v[i * 3 + 2]);
+            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 0]].transformPointAffine(vert, tmpV0).scaleBy(meshData.rawJointWeights[i * 4 + 0]);
+            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 1]].transformPointAffine(vert, tmpV1).scaleBy(meshData.rawJointWeights[i * 4 + 1]);
+            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 2]].transformPointAffine(vert, tmpV2).scaleBy(meshData.rawJointWeights[i * 4 + 2]);
+            skeleton.jointMatrices[meshData.rawBlendIndices[i * 4 + 3]].transformPointAffine(vert, tmpV3).scaleBy(meshData.rawJointWeights[i * 4 + 3]);
+            tmpV0.addBy(tmpV1).addBy(tmpV2).addBy(tmpV3);
+            if (tmpV0.x < minx) {
+                minx = tmpV0.x;
+                indices[0] = i;
+            }
+            if (tmpV0.x > maxx) {
+                maxx = tmpV0.x;
+                indices[1] = i;
+            }
+            if (tmpV0.y < miny) {
+                miny = tmpV0.y;
+                indices[2] = i;
+            }
+            if (tmpV0.y > maxy) {
+                maxy = tmpV0.y;
+                indices[3] = i;
+            }
+            if (tmpV0.z < minz) {
+                minz = tmpV0.z;
+                indices[4] = i;
+            }
+            if (tmpV0.z > maxz) {
+                maxz = tmpV0.z;
+                indices[5] = i;
+            }
+        }
+        const info = {
+            boundingVertexBlendIndices: new Float32Array(Array.from({
+                length: 6 * 4
+            }).map((val, index)=>meshData.rawBlendIndices[indices[index >> 2] * 4 + index % 4])),
+            boundingVertexJointWeights: new Float32Array(Array.from({
+                length: 6 * 4
+            }).map((val, index)=>meshData.rawJointWeights[indices[index >> 2] * 4 + index % 4])),
+            boundingVertices: Array.from({
+                length: 6
+            }).map((val, index)=>new Vector3(meshData.rawPositions[indices[index] * 3], meshData.rawPositions[indices[index] * 3 + 1], meshData.rawPositions[indices[index] * 3 + 2])),
+            boundingBox: new BoundingBox()
+        };
+        return info;
+    }
+    /** @internal */ setAssetNodeToSceneNode(scene, parent, model, assetNode, skeletonMeshMap, nodeMap) {
+        const node = new SceneNode(scene);
+        nodeMap.set(assetNode, node);
+        node.name = `${assetNode.name}`;
+        node.position.set(assetNode.position);
+        node.rotation.set(assetNode.rotation);
+        node.scale.set(assetNode.scaling);
+        if (assetNode.mesh) {
+            const meshData = assetNode.mesh;
+            const skeleton = assetNode.skeleton;
+            for (const subMesh of meshData.subMeshes){
+                const meshNode = new Mesh(scene);
+                meshNode.name = subMesh.name;
+                meshNode.clipMode = GraphNode.CLIP_INHERITED;
+                meshNode.showState = GraphNode.SHOW_INHERITED;
+                meshNode.pickMode = GraphNode.PICK_INHERITED;
+                meshNode.primitive = subMesh.primitive;
+                meshNode.material = subMesh.material;
+                // meshNode.drawBoundingBox = true;
+                meshNode.reparent(node);
+                if (skeleton) {
+                    if (!skeletonMeshMap.has(skeleton)) {
+                        skeletonMeshMap.set(skeleton, {
+                            mesh: [
+                                meshNode
+                            ],
+                            bounding: [
+                                subMesh
+                            ]
+                        });
+                    } else {
+                        skeletonMeshMap.get(skeleton).mesh.push(meshNode);
+                        skeletonMeshMap.get(skeleton).bounding.push(subMesh);
+                    }
+                }
+            }
+        }
+        node.reparent(parent);
+        for (const child of assetNode.children){
+            this.setAssetNodeToSceneNode(scene, node, model, child, skeletonMeshMap, nodeMap);
+        }
+    }
+    getHash(type, url, options) {
+        return `${type}:${url}:${!options?.linearColorSpace}`;
+    }
+}
+
+export { AssetManager };
+//# sourceMappingURL=assetmanager.js.map

package/dist/asset/assetmanager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assetmanager.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}