@zephyr3d/scene 0.1.0

package/dist/render/watermesh.js.map

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

package/dist/scene/environment.js

@@ -0,0 +1,146 @@
+import { Vector4 } from '@zephyr3d/base';
+import '../app.js';
+import './octree.js';
+import '../material/material.js';
+import '@zephyr3d/device';
+import '../shaders/framework.js';
+import '../render/scatteringlut.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import '../material/lightmodel.js';
+import '../render/forward.js';
+import { SkyRenderer } from '../render/sky.js';
+import '../render/clipmap.js';
+import { EnvIBL, EnvHemisphericAmbient, EnvConstantAmbient } from '../render/envlight.js';
+import '../render/watermesh.js';
+
+/**
+ * Wrapper for environmant lighting
+ * @public
+ */ class EnvLightWrapper {
+    _envLight;
+    _ambientColor;
+    _ambientDown;
+    _ambientUp;
+    _radianceMap;
+    _irradianceMap;
+    _strength;
+    /** @internal */ constructor(){
+        this._envLight = new EnvIBL();
+        this._ambientColor = new Vector4(0.2, 0.2, 0.2, 1);
+        this._ambientDown = new Vector4(0.2, 0.2, 0.2, 1);
+        this._ambientUp = new Vector4(0.3, 0.5, 0.8, 1);
+        this._radianceMap = null;
+        this._irradianceMap = null;
+        this._strength = 1;
+    }
+    /** @internal */ getHash(ctx) {
+        return ctx.drawEnvLight ? `${this.type}:${this._envLight.hasRadiance() ? '1' : '0'}:${this._envLight.hasIrradiance() ? '1' : '0'}` : 'none';
+    }
+    /** @internal */ get envLight() {
+        return this._envLight;
+    }
+    /** The strength of environment lighting */ get strength() {
+        return this._strength;
+    }
+    set strength(val) {
+        this._strength = val;
+    }
+    /** Ambient light color for environment light type constant */ get ambientColor() {
+        return this._ambientColor.clone();
+    }
+    set ambientColor(val) {
+        this._ambientColor.set(val);
+        if (this.type === 'constant') {
+            this._envLight.ambientColor = this._ambientColor;
+        }
+    }
+    /** Up color for environment light type hemisphere */ get ambientUp() {
+        return this._ambientUp.clone();
+    }
+    set ambientUp(val) {
+        this._ambientUp.set(val);
+        if (this.type === 'hemisphere') {
+            this._envLight.ambientUp = this._ambientUp;
+        }
+    }
+    /** Down color for environment light type hemisphere */ get ambientDown() {
+        return this._ambientDown.clone();
+    }
+    set ambientDown(val) {
+        this._ambientDown.set(val);
+        if (this.type === 'hemisphere') {
+            this._envLight.ambientDown = this._ambientDown;
+        }
+    }
+    /** Radiance map for environment light type ibl */ get radianceMap() {
+        return this._radianceMap;
+    }
+    set radianceMap(tex) {
+        this._radianceMap = tex ?? null;
+        if (this.type === 'ibl') {
+            this._envLight.radianceMap = this._radianceMap;
+        }
+    }
+    /** Irradiance map for environment light type ibl */ get irradianceMap() {
+        return this._irradianceMap;
+    }
+    set irradianceMap(tex) {
+        this._irradianceMap = tex ?? null;
+        if (this.type === 'ibl') {
+            this._envLight.irradianceMap = this._irradianceMap;
+        }
+    }
+    /** The environment light type */ get type() {
+        return this._envLight?.getType() ?? 'none';
+    }
+    set type(val) {
+        switch(val){
+            case 'none':
+                this._envLight = null;
+                break;
+            case 'ibl':
+                if (this._envLight?.getType() !== val) {
+                    this._envLight = new EnvIBL(this._radianceMap, this._irradianceMap);
+                }
+                break;
+            case 'constant':
+                if (this._envLight?.getType() !== val) {
+                    this._envLight = new EnvConstantAmbient(this._ambientColor);
+                }
+                break;
+            case 'hemisphere':
+                if (this._envLight?.getType() !== val) {
+                    this._envLight = new EnvHemisphericAmbient(this._ambientUp, this._ambientDown);
+                }
+                break;
+        }
+    }
+}
+/**
+ * Environment of scene
+ * @public
+ */ class Environment {
+    _sky;
+    _light;
+    /** @internal */ constructor(){
+        this._sky = new SkyRenderer();
+        this._light = new EnvLightWrapper();
+    }
+    /** The sky renderer */ get sky() {
+        return this._sky;
+    }
+    /** The environment lighting renderer */ get light() {
+        return this._light;
+    }
+    /** @internal */ getHash(ctx) {
+        return `${this.light?.getHash(ctx)}:${this._sky?.getHash(ctx)}`;
+    }
+    /** @internal */ needSceneDepthTexture() {
+        return this._sky.fogType !== 'none';
+    }
+}
+
+export { EnvLightWrapper, Environment };
+//# sourceMappingURL=environment.js.map

package/dist/scene/environment.js.map

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

package/dist/scene/graph_node.js

@@ -0,0 +1,69 @@
+import { SceneNode } from './scene_node.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+/**
+ * Graph scene node
+ *
+ * @remarks
+ * Graph node is the base class of any kind of scene node that will be placed into the octree
+ *
+ * @public
+ */ class GraphNode extends SceneNode {
+    /**
+   * Creates a graph node
+   * @param scene - The scene to which the node belongs
+   */ constructor(scene){
+        super(scene);
+        this._renderOrder = 0;
+    }
+    /**
+   * Render order of the node
+   */ get renderOrder() {
+        return this._renderOrder;
+    }
+    set renderOrder(val) {
+        this._renderOrder = val;
+    }
+    /** Gets the name */ getName() {
+        return this._name;
+    }
+    /**
+   * {@inheritDoc SceneNode.isGraphNode}
+   * @override
+   */ isGraphNode() {
+        return true;
+    }
+    /**
+   * {@inheritDoc Drawable.getXForm}
+   */ getXForm() {
+        return this;
+    }
+    /**
+   * {@inheritDoc Drawable.getBoneMatrices}
+   */ getBoneMatrices() {
+        return null;
+    }
+    /**
+   * {@inheritDoc Drawable.getInvBindMatrix}
+   */ getInvBindMatrix() {
+        return null;
+    }
+    /**
+   * {@inheritDoc Drawable.getSortDistance}
+   */ getSortDistance(camera) {
+        const cameraWorldMatrix = camera.worldMatrix;
+        const objectWorldMatrix = this.worldMatrix;
+        const dx = cameraWorldMatrix.m03 - objectWorldMatrix.m03;
+        const dy = cameraWorldMatrix.m13 - objectWorldMatrix.m13;
+        const dz = cameraWorldMatrix.m23 - objectWorldMatrix.m23;
+        return dx * dx + dy * dy * dz * dz;
+    }
+    /**
+   * {@inheritDoc Drawable.isBatchable}
+   */ isBatchable() {
+        return false;
+    }
+}
+
+export { GraphNode };
+//# sourceMappingURL=graph_node.js.map

package/dist/scene/graph_node.js.map

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

package/dist/scene/light.js

@@ -0,0 +1,436 @@
+import { Vector4, Matrix4x4, Vector3 } from '@zephyr3d/base';
+import { GraphNode } from './graph_node.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { ShadowMapper } from '../shadow/shadowmapper.js';
+import { LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
+
+/**
+ * Base class for any kind of light node
+ * @public
+ */ class BaseLight extends GraphNode {
+    /** @internal */ _type;
+    /** @internal */ _intensity;
+    /** @internal */ _positionRange;
+    /** @internal */ _directionCutoff;
+    /** @internal */ _diffuseIntensity;
+    /**
+   * Creates a light node
+   * @param scene - The scene to which the light node belongs
+   * @param type - Type of the light node
+   */ constructor(scene, type){
+        super(scene);
+        this._intensity = 1;
+        this._type = type;
+        this._positionRange = null;
+        this._directionCutoff = null;
+        this._diffuseIntensity = null;
+    }
+    /** Gets the light type */ get lightType() {
+        return this._type;
+    }
+    /** Intensity of the light */ get intensity() {
+        return this._intensity;
+    }
+    set intensity(val) {
+        this.setIntensity(val);
+    }
+    /**
+   * Position and range of the light
+   *
+   * @remarks
+   * Gets the position in world space of the light.
+   * Light range is encoded into the W component.
+   */ get positionAndRange() {
+        if (!this._positionRange) {
+            this.computeUniforms();
+        }
+        return this._positionRange;
+    }
+    /**
+   * Direction and cutoff of the light
+   *
+   * @remarks
+   * Gets the direction in world space of the light
+   * Light cutoff (for spot light only) is encoded into the W component.
+   */ get directionAndCutoff() {
+        if (!this._directionCutoff) {
+            this.computeUniforms();
+        }
+        return this._directionCutoff;
+    }
+    /**
+   * Color and intensity of the light
+   *
+   * @remarks
+   * Gets the color of the light.
+   * Light intensity is encoded into the W component.
+   */ get diffuseAndIntensity() {
+        if (!this._diffuseIntensity) {
+            this.computeUniforms();
+        }
+        return this._diffuseIntensity;
+    }
+    /**
+   * View matrix of the light
+   *
+   * @remarks
+   * The view matrix of the light is used to transform a point
+   * from the world space to the light space.
+   */ get viewMatrix() {
+        return this.invWorldMatrix;
+    }
+    /**
+   * View-projection matrix of the light
+   *
+   * @remarks
+   * The view-projection matrix of the light is used to transform
+   * a point from the world space to the clip space of the light view
+   */ get viewProjMatrix() {
+        return null;
+    }
+    /**
+   * Sets the intensity of the light
+   * @param val - Intensity of the light
+   * @returns self
+   */ setIntensity(val) {
+        if (this._intensity !== val) {
+            this._intensity = val;
+            this.invalidateUniforms();
+        }
+        return this;
+    }
+    /** @internal */ invalidateUniforms() {
+        this._positionRange = null;
+        this._directionCutoff = null;
+        this._diffuseIntensity = null;
+    }
+    /** {@inheritDoc SceneNode.isLight} */ isLight() {
+        return true;
+    }
+    /** {@inheritDoc SceneNode.isPunctualLight} */ isPunctualLight() {
+        return false;
+    }
+    /** returns true if this is a directional light */ isDirectionLight() {
+        return false;
+    }
+    /** returns true if this is a point light */ isPointLight() {
+        return false;
+    }
+    /** returns true if this is a spot light */ isSpotLight() {
+        return false;
+    }
+}
+/*
+export abstract class AmbientLight extends BaseLight {
+  constructor(scene: Scene, type: number) {
+    super(scene, type);
+  }
+  isAmbientLight(): this is AmbientLight {
+    return true;
+  }
+}
+*/ /*
+export class HemiSphericLight extends AmbientLight {
+  protected _colorUp: Vector4;
+  protected _colorDown: Vector4;
+  constructor(scene: Scene) {
+    super(scene, LIGHT_TYPE_HEMISPHERIC);
+    this._colorUp = Vector4.zero();
+    this._colorDown = Vector4.zero();
+  }
+  get colorUp() {
+    return this._colorUp;
+  }
+  set colorUp(val: Vector4) {
+    this.setColorUp(val);
+  }
+  setColorUp(val: Vector4) {
+    this._colorUp.set(val);
+    this.invalidateUniforms();
+    return this;
+  }
+  get colorDown() {
+    return this._colorDown;
+  }
+  set colorDown(val: Vector4) {
+    this.setColorDown(val);
+  }
+  setColorDown(val: Vector4) {
+    this._colorDown.set(val);
+    this.invalidateUniforms();
+    return this;
+  }
+  isHemiSphericLight(): this is HemiSphericLight {
+    return true;
+  }
+  computeUniforms() {
+    this._positionRange = this.colorUp;
+    this._directionCutoff = this.colorDown;
+    this._diffuseIntensity = new Vector4(1, 1, 1, this.intensity);
+  }
+}
+*/ /**
+ * Base class for any kind of puncual light
+ * @public
+ */ class PunctualLight extends BaseLight {
+    /** @internal */ _color;
+    /** @internal */ _castShadow;
+    /** @internal */ _lightViewProjectionMatrix;
+    /** @internal */ _shadowMapper;
+    /**
+   * Creates an instance of punctual light
+   * @param scene - The scene to which the punctual light belongs
+   * @param type - The light type
+   */ constructor(scene, type){
+        super(scene, type);
+        this._color = Vector4.one();
+        this._castShadow = false;
+        this._lightViewProjectionMatrix = Matrix4x4.identity();
+        this._shadowMapper = new ShadowMapper(this);
+    }
+    /** Color of the light */ get color() {
+        return this._color;
+    }
+    set color(clr) {
+        this.setColor(clr);
+    }
+    /**
+   * Sets color of the light
+   * @param color - The color to set
+   * @returns self
+   */ setColor(color) {
+        this._color.set(color);
+        this.invalidateUniforms();
+        return this;
+    }
+    /** Whether this light casts shadows */ get castShadow() {
+        return this._castShadow;
+    }
+    set castShadow(b) {
+        this.setCastShadow(b);
+    }
+    /**
+   * Sets whether this light casts shadows
+   * @param b - true if the light casts shadows
+   * @returns self
+   */ setCastShadow(b) {
+        this._castShadow = b;
+        return this;
+    }
+    /**
+   * {@inheritDoc BaseLight.viewProjMatrix}
+   * @override
+   */ get viewProjMatrix() {
+        return this._lightViewProjectionMatrix;
+    }
+    set viewProjMatrix(mat) {
+        this.setLightViewProjectionMatrix(mat);
+    }
+    /** The shadow mapper for this light */ get shadow() {
+        return this._shadowMapper;
+    }
+    /**
+   * Sets the view projection matrix for this light
+   * @param mat - The matrix to set
+   * @returns self
+   */ setLightViewProjectionMatrix(mat) {
+        this._lightViewProjectionMatrix.set(mat);
+        return this;
+    }
+    /**
+   * {@inheritDoc BaseLight.isPunctualLight}
+   * @override
+   */ isPunctualLight() {
+        return true;
+    }
+    /** @internal */ _onTransformChanged(invalidateLocal) {
+        super._onTransformChanged(invalidateLocal);
+        this.invalidateUniforms();
+    // this._transformCallback(true, false);
+    }
+}
+/**
+ * Directional light
+ * @public
+ */ class DirectionalLight extends PunctualLight {
+    static _currentSunLight = null;
+    _sunLight;
+    /**
+   * Creates an instance of directional light
+   * @param scene - The scene to which the light belongs
+   */ constructor(scene){
+        super(scene, LIGHT_TYPE_DIRECTIONAL);
+        if (!DirectionalLight._currentSunLight) {
+            DirectionalLight._currentSunLight = this;
+            this._sunLight = true;
+        } else {
+            this._sunLight = false;
+        }
+    }
+    /**
+   * true if the light was defined as sun light
+   *
+   * @remarks
+   * Only one directional light will be marked as sun light.
+   **/ get sunLight() {
+        return this._sunLight;
+    }
+    set sunLight(val) {
+        if (!!val !== this._sunLight) {
+            this._sunLight = !!val;
+            if (this._sunLight) {
+                DirectionalLight._currentSunLight._sunLight = false;
+                DirectionalLight._currentSunLight = this;
+            } else {
+                DirectionalLight._currentSunLight = null;
+            }
+        }
+        this._sunLight = !!val;
+    }
+    /**
+   * {@inheritDoc BaseLight.isDirectionLight}
+   * @override
+   */ isDirectionLight() {
+        return true;
+    }
+    /** @internal */ computeBoundingVolume(bv) {
+        return null;
+    }
+    /** @internal */ computeUniforms() {
+        const a = this.worldMatrix.getRow(3);
+        const b = this.worldMatrix.getRow(2).scaleBy(-1);
+        this._positionRange = new Vector4(a.x, a.y, a.z, -1);
+        this._directionCutoff = new Vector4(b.x, b.y, b.z, 0);
+        this._diffuseIntensity = new Vector4(this.color.x, this.color.y, this.color.z, this.intensity);
+    }
+}
+/**
+ * Point light
+ * @public
+ */ class PointLight extends PunctualLight {
+    /** @internal */ _range;
+    /**
+   * Creates an instance of point light
+   * @param scene - The scene to which the light belongs
+   */ constructor(scene){
+        super(scene, LIGHT_TYPE_POINT);
+        this._range = 1;
+        this.invalidateBoundingVolume();
+    }
+    /** The range of the light */ get range() {
+        return this._range;
+    }
+    set range(val) {
+        this.setRange(val);
+    }
+    /**
+   * Sets the range of the light
+   * @param val - The value to set
+   * @returns self
+   */ setRange(val) {
+        val = val < 0 ? 0 : val;
+        if (this._range !== val) {
+            this._range = val;
+            this.invalidateUniforms();
+            this.invalidateBoundingVolume();
+        }
+        return this;
+    }
+    /**
+   * {@inheritDoc BaseLight.isPointLight}
+   * @override
+   */ isPointLight() {
+        return true;
+    }
+    /** @internal */ computeBoundingVolume(bv) {
+        const bbox = bv ? bv : new BoundingBox();
+        bbox.minPoint = new Vector3(-this._range, -this._range, -this._range);
+        bbox.maxPoint = new Vector3(this._range, this._range, this._range);
+        return bbox;
+    }
+    /** @internal */ computeUniforms() {
+        const a = this.worldMatrix.getRow(3);
+        const b = this.worldMatrix.getRow(2);
+        this._positionRange = new Vector4(a.x, a.y, a.z, this.range);
+        this._directionCutoff = new Vector4(b.x, b.y, b.z, -1);
+        this._diffuseIntensity = new Vector4(this.color.x, this.color.y, this.color.z, this.intensity);
+    }
+}
+/**
+ * Spot light
+ * @public
+ */ class SpotLight extends PunctualLight {
+    /** @internal */ _range;
+    /** @internal */ _cutoff;
+    /**
+   * Creates an instance of spot light
+   * @param scene - The scene to which the light belongs
+   */ constructor(scene){
+        super(scene, LIGHT_TYPE_SPOT);
+        this._range = 1;
+        this._cutoff = Math.cos(Math.PI / 4);
+        this.invalidateBoundingVolume();
+    }
+    /** The range of the light */ get range() {
+        return this._range;
+    }
+    set range(val) {
+        this.setRange(val);
+    }
+    /**
+   * Sets the range of the light
+   * @param val - The value to set
+   * @returns self
+   */ setRange(val) {
+        val = val < 0 ? 0 : val;
+        if (this._range !== val) {
+            this._range = val;
+            this.invalidateUniforms();
+            this.invalidateBoundingVolume();
+        }
+        return this;
+    }
+    /** The cutoff of the light */ get cutoff() {
+        return this._cutoff;
+    }
+    set cutoff(val) {
+        this.setCutoff(val);
+    }
+    /**
+   * Sets the cutoff of the light
+   * @param val - The value to set
+   * @returns self
+   */ setCutoff(val) {
+        val = val < 0 ? 0 : val;
+        if (this._cutoff !== val) {
+            this._cutoff = val;
+            this.invalidateUniforms();
+            this.invalidateBoundingVolume();
+        }
+        return this;
+    }
+    /**
+   * {@inheritDoc BaseLight.isSpotLight}
+   * @override
+   */ isSpotLight() {
+        return true;
+    }
+    /** @internal */ computeBoundingVolume(bv) {
+        const bbox = bv ? bv : new BoundingBox();
+        const cosCutoff = Math.cos(this._cutoff);
+        const r = this._range / cosCutoff * Math.sqrt(1 - cosCutoff * cosCutoff);
+        bbox.minPoint = new Vector3(-r, -r, 0);
+        bbox.maxPoint = new Vector3(r, r, this._range);
+        return bbox;
+    }
+    /** @internal */ computeUniforms() {
+        const a = this.worldMatrix.getRow(3);
+        const b = this.worldMatrix.getRow(2).scaleBy(-1);
+        this._positionRange = new Vector4(a.x, a.y, a.z, this.range);
+        this._directionCutoff = new Vector4(b.x, b.y, b.z, Math.cos(this.cutoff));
+        this._diffuseIntensity = new Vector4(this.color.x, this.color.y, this.color.z, this.intensity);
+    }
+}
+
+export { BaseLight, DirectionalLight, PointLight, PunctualLight, SpotLight };
+//# sourceMappingURL=light.js.map

package/dist/scene/light.js.map

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