@openglobus/og 0.17.2 → 0.18.1

package/lib/js/Object3d.d.ts

@@ -0,0 +1,49 @@
+import { TypedArray } from './utils/shared';
+import { NumberArray3 } from './math/Vec3';
+interface IObject3dParams {
+    name?: string;
+    vertices?: number[];
+    texCoords?: number[];
+    indices?: number[];
+    normals?: number[];
+    center?: boolean;
+    src?: string;
+    color?: number[] | TypedArray | string;
+    scale?: number;
+}
+declare class Object3d {
+    protected _name: string;
+    protected _vertices: number[];
+    protected _numVertices: number;
+    protected _texCoords: number[];
+    /**
+     * Image src.
+     * @protected
+     * @type {string}
+     */
+    protected _src: string | null;
+    protected color: Float32Array;
+    protected _indices: number[];
+    protected _normals: number[];
+    constructor(data?: IObject3dParams);
+    static centering(verts: number[]): void;
+    get src(): string | null;
+    set src(src: string | null);
+    get name(): string;
+    get vertices(): number[];
+    get normals(): number[];
+    get indices(): number[];
+    get texCoords(): number[];
+    get numVertices(): number;
+    static scale(vertices: number[], s: number): void;
+    static centroid(vertices: number[]): number[];
+    static translate(vertices: number[], v: NumberArray3): void;
+    static getNormals(vertices: number[]): number[];
+    static createSphere(lonBands?: number, latBands?: number, radius?: number, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
+    static createDisc(radius?: number, height?: number, radialSegments?: number, isTop?: boolean, startIndex?: number, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
+    static createCylinder(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, isTop?: boolean, isBottom?: boolean, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
+    static createCube(length?: number, height?: number, depth?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
+    static createArrow(back?: number, height?: number, front?: number): Object3d;
+    static loadObj(src: string): Promise<Object3d[]>;
+}
+export { Object3d };

package/lib/js/Object3d.js

@@ -0,0 +1,309 @@
+import { htmlColorToFloat32Array } from './utils/shared';
+import { Vec3 } from './math/Vec3';
+import { MAX, MIN } from './math';
+import { transformLeftToRightCoordinateSystem, objParser } from "./utils/objParser";
+function getColor(color) {
+    if (color instanceof Array) {
+        return new Float32Array(color);
+    }
+    else if (typeof color === 'string') {
+        return htmlColorToFloat32Array(color);
+    }
+    return new Float32Array([1.0, 1.0, 1.0, 1.0]);
+}
+class Object3d {
+    constructor(data = {}) {
+        this._name = data.name || "noname";
+        this._vertices = data.vertices || [];
+        this._numVertices = this._vertices.length / 3;
+        this._texCoords = data.texCoords || new Array(2 * this._numVertices);
+        if (data.center) {
+            Object3d.centering(this._vertices);
+        }
+        /**
+         * Image src.
+         * @protected
+         * @type {string}
+         */
+        this._src = data.src || null;
+        this.color = getColor(data.color);
+        if (data.scale) {
+            Object3d.scale(this._vertices, data.scale);
+        }
+        if (data.indices) {
+            this._indices = data.indices;
+            this._normals = data.normals || [];
+        }
+        else {
+            this._normals = Object3d.getNormals(this._vertices);
+            this._indices = new Array(this._vertices.length / 3);
+            for (let i = 0, len = this._indices.length; i < len; i++) {
+                this._indices[i] = i;
+            }
+        }
+    }
+    static centering(verts) {
+        let min_x = MAX, min_y = MAX, min_z = MAX, max_x = MIN, max_y = MIN, max_z = MIN;
+        for (let i = 0, len = verts.length; i < len; i += 3) {
+            let x = verts[i], y = verts[i + 1], z = verts[i + 2];
+            if (x < min_x)
+                min_x = x;
+            if (y < min_y)
+                min_y = y;
+            if (z < min_z)
+                min_z = z;
+            if (x > max_x)
+                max_x = x;
+            if (y > max_y)
+                max_y = y;
+            if (z > max_z)
+                max_z = z;
+        }
+        let c_x = min_x + (max_x - min_x) * 0.5;
+        let c_y = min_y + (max_y - min_y) * 0.5;
+        let c_z = min_z + (max_z - min_z) * 0.5;
+        for (let i = 0, len = verts.length; i < len; i += 3) {
+            verts[i] -= c_x;
+            verts[i + 1] -= c_y;
+            verts[i + 2] -= c_z;
+        }
+    }
+    get src() {
+        return this._src;
+    }
+    set src(src) {
+        this._src = src;
+    }
+    get name() {
+        return this._name;
+    }
+    get vertices() {
+        return this._vertices;
+    }
+    get normals() {
+        return this._normals;
+    }
+    get indices() {
+        return this._indices;
+    }
+    get texCoords() {
+        return this._texCoords;
+    }
+    get numVertices() {
+        return this._numVertices;
+    }
+    static scale(vertices, s) {
+        for (let i = 0; i < vertices.length; i++) {
+            vertices[i] *= s;
+        }
+    }
+    static centroid(vertices) {
+        let minX = 1000.0, minY = 1000.0, minZ = 1000.0, maxX = -1000.0, maxY = -1000.0, maxZ = -1000.0;
+        for (let i = 0; i < vertices.length; i += 3) {
+            let x = vertices[i], y = vertices[i + 1], z = vertices[i + 2];
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (z < minZ)
+                minZ = z;
+            if (x > maxX)
+                maxX = x;
+            if (y > maxY)
+                maxY = y;
+            if (z > maxZ)
+                maxZ = z;
+        }
+        return [minX + (maxX - minX) * 0.5, minY + (maxY - minY) * 0.5, minZ + (maxZ - minZ) * 0.5];
+    }
+    static translate(vertices, v) {
+        for (let i = 0; i < vertices.length; i += 3) {
+            vertices[i] -= v[0];
+            vertices[i + 1] -= v[1];
+            vertices[i + 2] -= v[2];
+        }
+    }
+    static getNormals(vertices) {
+        let res = new Array(vertices.length);
+        for (let i = 0; i < vertices.length; i += 9) {
+            let t03 = i, t13 = i + 3, t23 = i + 6, v0_x = vertices[t03], v0_y = vertices[t03 + 1], v0_z = vertices[t03 + 2], v1_x = vertices[t13], v1_y = vertices[t13 + 1], v1_z = vertices[t13 + 2], v2_x = vertices[t23], v2_y = vertices[t23 + 1], v2_z = vertices[t23 + 2], vv0_x = v1_x - v0_x, vv0_y = v1_y - v0_y, vv0_z = v1_z - v0_z, vv1_x = v2_x - v0_x, vv1_y = v2_y - v0_y, vv1_z = v2_z - v0_z, n_x = vv0_y * vv1_z - vv0_z * vv1_y, n_y = vv0_z * vv1_x - vv0_x * vv1_z, n_z = vv0_x * vv1_y - vv0_y * vv1_x;
+            let l = Math.sqrt(n_x * n_x + n_y * n_y + n_z * n_z);
+            n_x /= l;
+            n_y /= l;
+            n_z /= l;
+            res[t03] = n_x;
+            res[t03 + 1] = n_y;
+            res[t03 + 2] = n_z;
+            res[t13] = n_x;
+            res[t13 + 1] = n_y;
+            res[t13 + 2] = n_z;
+            res[t23] = n_x;
+            res[t23 + 1] = n_y;
+            res[t23 + 2] = n_z;
+        }
+        return res;
+    }
+    static createSphere(lonBands = 16, latBands = 16, radius = 1.0, offsetX = 0, offsetY = 0, offsetZ = 0) {
+        let vertices = [], indices = [], normals = [];
+        for (let latNumber = 0; latNumber <= latBands; latNumber++) {
+            let theta = latNumber * Math.PI / latBands;
+            let sinTheta = Math.sin(theta);
+            let cosTheta = Math.cos(theta);
+            for (let longNumber = 0; longNumber <= lonBands; longNumber++) {
+                let phi = longNumber * 2 * Math.PI / lonBands;
+                let sinPhi = Math.sin(phi);
+                let cosPhi = Math.cos(phi);
+                let x = cosPhi * sinTheta + offsetX;
+                let y = cosTheta + offsetY;
+                let z = sinPhi * sinTheta + offsetZ;
+                //var u = 1 - (longNumber / lonBands);
+                //var v = latNumber / latBands;
+                normals.push(x);
+                normals.push(y);
+                normals.push(z);
+                //texCoords.push(u);
+                //texCoords.push(v);
+                vertices.push(radius * x);
+                vertices.push(radius * y);
+                vertices.push(radius * z);
+            }
+        }
+        for (let latNumber = 0; latNumber < latBands; latNumber++) {
+            for (let longNumber = 0; longNumber < lonBands; longNumber++) {
+                let first = (latNumber * (lonBands + 1)) + longNumber;
+                let second = first + lonBands + 1;
+                indices.push(first);
+                indices.push(first + 1);
+                indices.push(second);
+                indices.push(second);
+                indices.push(first + 1);
+                indices.push(second + 1);
+            }
+        }
+        return new Object3d({
+            'vertices': vertices, 'normals': normals, 'indices': indices
+        });
+    }
+    static createDisc(radius = 1.0, height = 0.0, radialSegments = 8, isTop = true, startIndex = 0, offsetX = 0, offsetY = 0, offsetZ = 0) {
+        let vertices = [], indices = [], normals = [];
+        let thetaStart = 0.0, thetaLength = Math.PI * 2;
+        let sign = isTop ? 1.0 : -1.0;
+        let centerIndexStart = startIndex;
+        for (let x = 1; x <= radialSegments; x++) {
+            vertices.push(offsetX, height * sign + offsetY, offsetZ);
+            normals.push(0, sign, 0);
+            //texCoords.push(0.5, 0.5);
+            startIndex++;
+        }
+        let centerIndexEnd = startIndex;
+        for (let x = 0; x <= radialSegments; x++) {
+            let u = x / radialSegments;
+            let theta = u * thetaLength + thetaStart;
+            let cosTheta = Math.cos(theta);
+            let sinTheta = Math.sin(theta);
+            vertices.push(radius * sinTheta + offsetX, height * sign + offsetY, radius * cosTheta + offsetZ);
+            normals.push(0, sign, 0);
+            //texCoords.push((cosTheta * 0.5) + 0.5, (sinTheta * 0.5 * sign) + 0.5);
+            startIndex++;
+        }
+        for (let x = 0; x < radialSegments; x++) {
+            let c = centerIndexStart + x, i = centerIndexEnd + x;
+            if (isTop) {
+                indices.push(i, i + 1, c);
+            }
+            else {
+                indices.push(i + 1, i, c);
+            }
+        }
+        return new Object3d({
+            'vertices': vertices, 'normals': normals, 'indices': indices
+        });
+    }
+    static createCylinder(radiusTop = 1.0, radiusBottom = 1.0, height = 1.0, radialSegments = 32, heightSegments = 1.0, isTop = true, isBottom = true, offsetX = 0, offsetY = 0, offsetZ = 0) {
+        let vertices = [], indices = [], normals = [];
+        let thetaStart = 0.0, thetaLength = Math.PI * 2;
+        let index = 0;
+        let indexArray = [];
+        let normal = new Vec3();
+        let slope = (radiusBottom - radiusTop) / height;
+        for (let y = 0; y <= heightSegments; y++) {
+            let indexRow = [];
+            let v = y / heightSegments;
+            let radius = v * (radiusBottom - radiusTop) + radiusTop;
+            for (let x = 0; x <= radialSegments; x++) {
+                let u = x / radialSegments;
+                let theta = u * thetaLength + thetaStart;
+                let sinTheta = Math.sin(theta), cosTheta = Math.cos(theta);
+                vertices.push(radius * sinTheta + offsetX, -v * height + height + offsetY, radius * cosTheta + offsetZ);
+                normal.set(sinTheta, slope, cosTheta).normalize();
+                normals.push(normal.x, normal.y, normal.z);
+                //texCoords.push(u, 1 - v);
+                indexRow.push(index++);
+            }
+            indexArray.push(indexRow);
+        }
+        for (let x = 0; x < radialSegments; x++) {
+            for (let y = 0; y < heightSegments; y++) {
+                let a = indexArray[y][x], b = indexArray[y + 1][x], c = indexArray[y + 1][x + 1], d = indexArray[y][x + 1];
+                indices.push(a, b, d);
+                indices.push(b, c, d);
+            }
+        }
+        if (radiusTop !== 0.0 && isTop) {
+            let cap = Object3d.createDisc(radiusTop, height, radialSegments, true, index, offsetX, offsetY, offsetZ);
+            vertices.push(...cap.vertices);
+            normals.push(...cap.normals);
+            indices.push(...cap.indices);
+        }
+        if (radiusBottom !== 0.0 && isBottom) {
+            let cap = Object3d.createDisc(radiusBottom, 0, radialSegments, false, index + (isTop ? (1 + 2 * radialSegments) : 0), offsetX, offsetY, offsetZ);
+            vertices.push(...cap.vertices);
+            normals.push(...cap.normals);
+            indices.push(...cap.indices);
+        }
+        return new Object3d({
+            vertices: vertices,
+            normals: normals,
+            indices: indices
+        });
+    }
+    static createCube(length = 1, height = 1, depth = 1, xOffset = 0, yOffset = 0, zOffset = 0) {
+        let l = length * 0.5 + xOffset, h = height * 0.5 + yOffset, d = depth * 0.5 + zOffset;
+        return new Object3d({
+            vertices: [
+                -l, -h, d, l, -h, -d, l, -h, d, -l, -h, d, -l, -h, -d, l, -h, -d,
+                //top
+                -l, h, d, l, h, d, l, h, -d, -l, h, d, l, h, -d, -l, h, -d,
+                //front
+                -l, -h, d, l, -h, d, -l, h, d, -l, h, d, l, -h, d, l, h, d,
+                //back
+                -l, -h, -d, -l, h, -d, l, -h, -d, -l, h, -d, l, h, -d, l, -h, -d,
+                //left
+                l, -h, d, l, -h, -d, l, h, d, l, h, d, l, -h, -d, l, h, -d,
+                //right
+                -l, -h, d, -l, h, d, -l, -h, -d, -l, h, d, -l, h, -d, -l, -h, -d
+            ]
+        });
+    }
+    static createArrow(back = 0.0, height = 2.1, front = -15) {
+        return new Object3d({
+            vertices: [0, height, 0, 7, 0, 6, 0, 0, front,
+                0, 0, back, 7, 0, 6, 0, height, 0,
+                -7, 0, 6, 0, 0, back, 0, height, 0,
+                -7, 0, 6, 0, height, 0, 0, 0, front,
+                -7, 0, 6, 0, 0, front, 0, 0, back, 0, 0, back, 0, 0, front, 7, 0, 6]
+        });
+    }
+    static async loadObj(src) {
+        const obj = await fetch(src, { mode: "cors", })
+            .then((response) => response.text())
+            .then((data) => transformLeftToRightCoordinateSystem(objParser(data)))
+            .catch(() => []);
+        return obj.geometries.map(({ data: { vertices, normals, textures } }) => new Object3d({
+            vertices,
+            normals,
+            texCoords: textures
+        }));
+    }
+}
+export { Object3d };

package/lib/js/Popup.d.ts

@@ -0,0 +1,46 @@
+import { EventsHandler } from "./Events";
+import { LonLat } from "./LonLat";
+import { Planet } from "./scene/Planet";
+import { NumberArray2, Vec2 } from "./math/Vec2";
+import { NumberArray3, Vec3 } from "./math/Vec3";
+import { View, IViewParams, ViewEventsList } from './ui/View';
+interface IPopupParams extends IViewParams {
+    planet: Planet;
+    title?: string;
+    className?: string;
+    visibility?: boolean;
+    content?: string;
+    offset?: NumberArray2;
+    lonLat?: LonLat | NumberArray2 | NumberArray3;
+}
+type PopupEventsList = ["open", "close"];
+declare class Popup extends View<null> {
+    events: EventsHandler<PopupEventsList> & EventsHandler<ViewEventsList>;
+    $content: HTMLElement | null;
+    $tip: HTMLElement | null;
+    $title: HTMLElement | null;
+    protected _content: string | HTMLElement | null;
+    protected _planet: Planet;
+    protected _offset: NumberArray2;
+    protected _lonLat: LonLat;
+    protected _cartPos: Vec3;
+    protected _visibility: boolean;
+    constructor(options: IPopupParams);
+    _updatePosition(): void;
+    setScreen(p: Vec2): void;
+    get clientWidth(): number;
+    get clientHeight(): number;
+    setOffset(x?: number, y?: number): this;
+    render(params?: any): this;
+    setVisibility(visibility: boolean): this;
+    getContainer(): HTMLElement | null;
+    getToolbarContainer(): HTMLElement;
+    show(): this;
+    hide(): this;
+    setCartesian3v(cart: Vec3, height?: number): this;
+    setTitle(html: string): void;
+    setLonLat(lonLat: LonLat): void;
+    setContent(content?: string | HTMLElement | null): void;
+    clear(): void;
+}
+export { Popup };

package/lib/js/Popup.js

@@ -0,0 +1,160 @@
+import { CLOSE_ICON } from './ui/icons';
+import { createLonLat, stringTemplate } from "./utils/shared";
+import { Vec3 } from "./math/Vec3";
+import { View } from './ui/View';
+const TEMPLATE = `<div class="og-popup {className}">
+      <div class="og-popup-content-wrapper">
+        <div class="og-popup-content"></div>
+      </div>
+      <div class="og-popup-tip-container">
+        <div class="og-popup-tip"></div>
+      </div>
+      <div class="og-popup-toolbar">
+        <div class="og-popup-btn og-popup-close">${CLOSE_ICON}</div>
+      </div>
+      <div class="og-popup-title">{title}</div>
+    </div>`;
+const POPUP_EVENTS = ["open", "close"];
+class Popup extends View {
+    constructor(options) {
+        super({
+            template: stringTemplate(TEMPLATE, {
+                title: options.title || ""
+            }),
+            classList: options.className ? [options.className] : [],
+            ...options
+        });
+        //@ts-ignore
+        this.events = this.events.registerNames(POPUP_EVENTS);
+        this._content = options.content || "";
+        this.$content = null;
+        this.$tip = null;
+        this.$title = null;
+        this._planet = options.planet;
+        this._offset = options.offset || [0, 0];
+        this._lonLat = createLonLat(options.lonLat);
+        this._cartPos = new Vec3();
+        this._visibility = options.visibility || false;
+        this.render();
+    }
+    _updatePosition() {
+        this.setCartesian3v(this._cartPos);
+    }
+    setScreen(p) {
+        if (this._planet) {
+            let r = this._planet.renderer.handler.pixelRatio;
+            this.el.style.transform =
+                `translate(${p.x / r - this.clientWidth * 0.5}px, ${p.y / r - this._planet.renderer.handler.canvas.clientHeight - this.$tip.clientHeight}px)`;
+        }
+    }
+    get clientWidth() {
+        return this.el ? this.el.clientWidth : 0;
+    }
+    get clientHeight() {
+        return this.el ? this.el.clientHeight : 0;
+    }
+    setOffset(x = 0, y = 0) {
+        this._offset[0] = x;
+        this._offset[1] = y;
+        if (this.el) {
+            this.el.style.left = `${x}px`;
+            this.el.style.bottom = `${y}px`;
+        }
+        return this;
+    }
+    render(params) {
+        super.render(params);
+        this.$content = this.select(".og-popup-content");
+        this.$title = this.select(".og-popup-title");
+        this.$tip = this.select(".og-popup-tip-container");
+        this.setOffset(this._offset[0], this._offset[1]);
+        this.setContent(this._content);
+        this.setLonLat(this._lonLat);
+        this.setVisibility(this._visibility);
+        this.select(".og-popup-close").addEventListener("click", () => {
+            this.hide();
+        });
+        return this;
+    }
+    setVisibility(visibility) {
+        if (visibility) {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+        return this;
+    }
+    getContainer() {
+        return this.$content;
+    }
+    getToolbarContainer() {
+        return this.select(".og-popup-toolbar");
+    }
+    show() {
+        this._visibility = true;
+        if (this._planet) {
+            this._planet.events.on("draw", this._updatePosition, this);
+            this.appendTo(this._planet.renderer.div);
+            this.events.dispatch(this.events.open, this);
+        }
+        return this;
+    }
+    hide() {
+        this._visibility = false;
+        if (this.el && this.el.parentNode) {
+            this._planet.events.off("draw", this._updatePosition);
+            this.el.parentNode.removeChild(this.el);
+            this.events.dispatch(this.events.close, this);
+        }
+        return this;
+    }
+    setCartesian3v(cart, height = 0) {
+        this._cartPos = cart;
+        if (this._planet) {
+            let cam = this._planet.camera;
+            let f = this._planet.ellipsoid.equatorialSize + height, g = cam._lonLat.height;
+            let look = cart.sub(cam.eye), v = Math.sqrt((f + g) * (f + g) - f * f);
+            if (v > look.length() && cam.getForward().dot(look.normalize()) > 0.0) {
+                this.el.style.display = "block";
+                this.setScreen(cam.project(cart));
+            }
+            else {
+                this.el.style.display = "none";
+            }
+        }
+        return this;
+    }
+    setTitle(html) {
+        if (this.$title) {
+            this.$title.innerHTML = html;
+        }
+    }
+    setLonLat(lonLat) {
+        this._lonLat = lonLat;
+        if (this._planet) {
+            this.setCartesian3v(this._planet.ellipsoid.lonLatToCartesian(lonLat), lonLat.height);
+        }
+    }
+    setContent(content) {
+        if (content) {
+            this.clear();
+            this._content = content;
+            if (this.$content) {
+                if (typeof content === "string") {
+                    this.$content.innerHTML = content;
+                }
+                else {
+                    this.$content.appendChild(content);
+                }
+            }
+        }
+    }
+    clear() {
+        this._content = null;
+        if (this.$content) {
+            this.$content.innerHTML = "";
+        }
+    }
+}
+export { Popup };

package/lib/js/QueueArray.d.ts

@@ -0,0 +1,16 @@
+declare class QueueArray<T> {
+    protected _size: number;
+    protected _array: T[];
+    protected _popIndex: number;
+    protected _shiftIndex: number;
+    length: number;
+    constructor(size?: number);
+    reset(): void;
+    clear(): void;
+    push(data: T): void;
+    pop(): T | undefined;
+    unshift(data: T): void;
+    shift(): T | undefined;
+    forEach(callback: (el: T) => void): void;
+}
+export { QueueArray };

package/lib/js/QueueArray.js

@@ -0,0 +1,63 @@
+class QueueArray {
+    constructor(size = 2048) {
+        this._size = size;
+        this._array = new Array(this._size);
+        this._popIndex = Math.floor(this._size * 0.5);
+        this._shiftIndex = this._popIndex;
+        this.length = 0;
+    }
+    reset() {
+        this._popIndex = Math.floor(this._size * 0.5);
+        this._shiftIndex = this._popIndex;
+        this.length = 0;
+    }
+    clear() {
+        this._array.length = 0;
+        this._array = new Array(this._size);
+        this._popIndex = Math.floor(this._size * 0.5);
+        this._shiftIndex = this._popIndex;
+        this.length = 0;
+    }
+    push(data) {
+        this.length++;
+        this._array[this._popIndex++] = data;
+    }
+    pop() {
+        if (this.length) {
+            this.length--;
+            let res = this._array[--this._popIndex];
+            // @ts-ignore
+            this._array[this._popIndex] = null;
+            if (!this._array[this._popIndex - 1]) {
+                this._popIndex = Math.floor(this._size * 0.5);
+                this._shiftIndex = this._popIndex;
+            }
+            return res;
+        }
+        return undefined;
+    }
+    unshift(data) {
+        this.length++;
+        this._array[--this._shiftIndex] = data;
+    }
+    shift() {
+        if (this.length) {
+            this.length--;
+            let res = this._array[this._shiftIndex];
+            // @ts-ignore
+            this._array[this._shiftIndex++] = null;
+            if (!this._array[this._shiftIndex]) {
+                this._popIndex = Math.floor(this._size * 0.5);
+                this._shiftIndex = this._popIndex;
+            }
+            return res;
+        }
+        return undefined;
+    }
+    forEach(callback) {
+        for (let i = this._shiftIndex; i < this._popIndex; i++) {
+            callback(this._array[i]);
+        }
+    }
+}
+export { QueueArray };