@pirireis/webglobeplugins 0.13.0-alpha → 0.15.0-alpha

package/semiplugins/shape-on-terrain/derived/padding-plugin.js

@@ -0,0 +1,101 @@
+import { ArcOnTerrainPlugin } from "../arc-plugin";
+const EDGE_COUNT = 5;
+const paddingKeys = (padding) => {
+    const stepCount = padding.coverAngle / padding.stepAngle;
+    const keys = new Array(Math.ceil(stepCount));
+    for (let i = 0; i < stepCount; i++) {
+        keys[i] = padding.key + i;
+    }
+    if (keys.length > stepCount) {
+        keys[keys.length - 1] = padding.key + stepCount;
+    }
+    return keys;
+};
+const adapterPadding2Arc = (globe, padding) => {
+    const stepCount = padding.coverAngle / padding.stepAngle;
+    const result = new Array(Math.ceil(stepCount));
+    const fill = (i, angle) => {
+        const startPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.outerRadius, angle);
+        const endPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.innerRadius, angle);
+        result[i] = {
+            key: padding.key + i,
+            start: [startPoint.long, startPoint.lat],
+            end: [endPoint.long, endPoint.lat],
+            color: padding.color,
+            height: padding.height,
+        };
+    };
+    for (let i = 0; i < stepCount; i++) {
+        const angle = padding.startAngle + i * padding.stepAngle;
+        fill(i, angle);
+    }
+    if (result.length > stepCount) {
+        const i = result.length - 1;
+        const angle = padding.startAngle + padding.coverAngle;
+        fill(i, angle);
+    }
+    return result;
+};
+export const chargerAdaptor = (chargerInput, plugin, padding) => {
+};
+export class PaddingPlugin {
+    id;
+    arcPlugin;
+    globe = null;
+    _memory = new Map();
+    isFreed = false;
+    constructor(id, { variativeColorsOn = true, defaultColor = [1, 1, 1, 1], defaultHeightFromGroundIn3D = 30.0, vertexCount = EDGE_COUNT } = {}) {
+        this.id = id;
+        this.arcPlugin = new ArcOnTerrainPlugin(id, {
+            cameraAttractionIsOn: false,
+            vertexCount: vertexCount,
+            variativeColorsOn: variativeColorsOn,
+            defaultColor: defaultColor,
+            defaultHeightFromGroundIn3D: defaultHeightFromGroundIn3D,
+        });
+    }
+    insertBulk(items) {
+        for (const padding of items) {
+            this.__delete(padding.key);
+            this._memory.set(padding.key, padding);
+        }
+        const arcInputs = items.flatMap(padding => adapterPadding2Arc(this.globe, padding));
+        this.arcPlugin.insertBulk(arcInputs);
+    }
+    deleteBulk(keys) {
+        const arcKeys = keys.flatMap(key => paddingKeys({ key, center: [0, 0], outerRadius: 0, innerRadius: 0, startAngle: 0, coverAngle: 0, stepAngle: 0, color: [0, 0, 0, 1] }));
+        this.arcPlugin.deleteBulk(arcKeys);
+    }
+    updateColor(key, color) {
+        // TODO: get all padding keys and update all of them
+        if (!this._memory.has(key)) {
+            console.warn(`Padding with key ${key} does not exist.`);
+            return;
+        }
+        const keys = paddingKeys(this._memory.get(key));
+        for (let i = 0; i < keys.length; i++) {
+            this.arcPlugin.updateColor(keys[i], color);
+        }
+    }
+    __delete(key) {
+        const padding = this._memory.get(key);
+        if (padding) {
+            const keys = paddingKeys(padding);
+            this.arcPlugin.deleteBulk(keys);
+            this._memory.delete(key);
+        }
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.arcPlugin.init(globe, gl);
+    }
+    draw3D() {
+        this.arcPlugin.draw3D();
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        this.isFreed = true;
+        this.arcPlugin.free();
+    }
+}

package/semiplugins/shape-on-terrain/one-degree-padding.js

@@ -0,0 +1,85 @@
+"use strict";
+// //      One Degree Padding
+// /**
+//  * 2d coordinates are loaded ones
+//  * 3d coordinates are calculated on the fly.
+//  *
+//  * 2d paddings are fixed size
+//  * 3d paddings gets shortened as lod increases
+//  *
+//  * color buffer is shared and does not change on unless insert or delete
+//  * changing color can be done by re inserting
+//  *
+//  *
+//  *
+//  */
+// import { Globe, LongLat, Meter, Color } from '../../types';
+// import { BufferManagersMap } from '../../util/account/single-attribute-buffer-management/types';
+// import { BufferManager } from '../../util/account/single-attribute-buffer-management/buffer-manager';
+// import { BufferOrchestrator } from '../../util/acconut/single-attribute-buffer-management/buffer-orchestrator';
+// import { LineStripProgramCache, LineProgram } from '../../programs/line-on-globe/linestrip/linestrip';
+// import { ProgramInterface } from '../../types';
+// export type OneDegreePaddingInput = {
+//     key: string;
+//     center: LongLat;
+//     outerRadius: Meter;
+//     color: Color;
+// };
+// const _float32Array = new Float32Array(360 * 3 * 2).fill(NaN);
+// export class Paddings1Degree implements ProgramInterface {
+//     id: string;
+//     private globe: Globe | null = null;
+//     private bufferOrchestrator: BufferOrchestrator;
+//     private bufferManagersMap: BufferManagersMap;
+//     private lineProgram: LineProgram | null = null;
+//     private _LODCoeffecientForPaddingScale: number = 1;
+//     private _PaddingSizeRatio = 0.1; // 0.1 means 10% of the padding size is used for 3d padding
+//     private _finalPaddingSizeRatio = 0.1; // this._LODCoefficientForPaddingScale * this._PaddingSizeRatio; // final padding size ratio is the product of LOD coefficient and padding size ratio
+//     constructor(id: string, { capacity = 1000 } = {}) {
+//         this.id = id;
+//         this.bufferOrchestrator = new BufferOrchestrator({ capacity });
+//         this.bufferManagersMap = new Map();
+//         this.lineProgram = null;
+//     }
+//     init(globe: Globe): void {
+//         this.globe = globe;
+//         this.lineProgram = LineStripProgramCache.get(globe);
+//     }
+//     __updateLODCoefficientForPaddingScale(): void {
+//         // TODO: call this ones when lod changes or each frame // maybe only on 3d geometry
+//     }
+//     __fillBufferManagersMap() {
+//         const globe = this.globe as Globe;
+//         const gl = globe.gl as WebGL2RenderingContext;
+//         this.bufferManagersMap.set("position2d", {
+//             bufferManager: new BufferManager(gl,
+//                 360 * (2 + 1), // plus 1 to cut
+//                 { bufferType: "STATIC_DRAW", initialCapacity: 10 }),
+//             adaptor: (PaddingInput: OneDegreePaddingInput) => {
+//                 for (let i = 0; i < 360; i++) {
+//                     let { long, lat } = globe.Math.FindPointByPolar(
+//                         PaddingInput.center[0], // center long
+//                         PaddingInput.center[1], // center lat
+//                         PaddingInput.outerRadius, // outer radius
+//                         i, // angle
+//                     )
+//                     let corrds = globe.api_GetMercator2DPoint(long, lat);
+//                     // fill the second coordinate with 0
+//                     _float32Array[i * 3] = corrds[0];
+//                     _float32Array[i * 3 + 1] = corrds[1];
+//                     ({ long, lat } = globe.Math.FindPointByPolar(
+//                         PaddingInput.center[0], // center long
+//                         PaddingInput.center[1], // center lat
+//                         PaddingInput.outerRadius * this._finalPaddingSizeRatio, // inner radius
+//                         i, // angle
+//                     ));
+//                     let innerCorrds = globe.api_GetMercator2DPoint(long, lat);
+//                     // fill the second coordinate with 0
+//                     _float32Array[i * 3 + 2] = innerCorrds[0];
+//                     _float32Array[i * 3 + 3] = innerCorrds[1];
+//                 }
+//                 return _float32Array;
+//             }
+//         });
+//         // Other methods like draw, insertBulk, deleteBulk, etc. would go here
+//     }

package/semiplugins/type.js

@@ -0,0 +1 @@
+export {};

package/types.js

@@ -1,12 +1 @@
-/**
- * @typedef DrawRange
- * @type {Object}
- * @property {int} first
- * @property {int} count
- *
- * @typedef DrawRangeIndexParamsClient
- * @type {Object}
- * @property {null|DrawRange} drawRange
- * @property {null|Int32List} indexes
- */
 export {};

package/util/account/create-buffermap-orchastration.js

@@ -0,0 +1,39 @@
+// IN construction
+import { BufferManager } from "./single-attribute-buffer-management/buffer-manager";
+import { BufferOrchestrator } from "./single-attribute-buffer-management/buffer-orchestrator";
+export class BufferMapOrchestrator {
+    gl;
+    bufferManagersMap;
+    bufferOrchestrator;
+    constructor(gl, bufferDetailsMap, initialCapacity = 10) {
+        this.gl = gl;
+        this.bufferManagersMap = new Map();
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
+        for (const [key, details] of bufferDetailsMap) {
+            const { itemSize, bufferType, adaptor } = details;
+            const bufferManager = new BufferManager(gl, itemSize, { bufferType, initialCapacity });
+            this.bufferManagersMap.set(key, { bufferManager, adaptor });
+        }
+    }
+    insertBulk(items) {
+        // @ts-ignore
+        this.bufferOrchestrator.insertBulk(items, this.bufferManagersMap);
+    }
+    updateBulk(items, bufferKeys = []) {
+        // @ts-ignore
+        this.bufferOrchestrator.updateBulk(items, this.bufferManagersMap, bufferKeys);
+    }
+    deleteBulk(keys) {
+        // @ts-ignore
+        this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersMap);
+    }
+    resetWithCapacity(capacity) {
+        this.bufferOrchestrator.resetWithCapacity(this.bufferManagersMap, capacity);
+    }
+    free() {
+        for (const [key, { bufferManager }] of this.bufferManagersMap) {
+            bufferManager.free();
+        }
+        this.bufferManagersMap.clear();
+    }
+}

package/util/account/single-attribute-buffer-management/buffer-orchestrator.js

@@ -19,7 +19,7 @@ export class BufferOrchestrator {
         this.tombstoneOffsets = [];
         this._length = 0;
     }
-    insertBulk(items, bufferManagersMap) {
+    insertBulk(items, bufferManagersMap, bufferKeys = null) {
         this.ensureSpace(items.length, bufferManagersMap);
         const { offsetMap } = this;
         const offsets = [];
@@ -29,8 +29,19 @@ export class BufferOrchestrator {
             offsetMap.set(item.key, offset);
             offsets.push(offset);
         }
-        for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-            bufferManager.insertBulk(items.map(adaptor), offsets);
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const bufferManagerComp = bufferManagersMap.get(key);
+                if (bufferManagerComp === undefined)
+                    throw new Error("insertBulk bufferKey does not exist");
+                const { bufferManager, adaptor } = bufferManagerComp;
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        }
+        else {
+            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
         }
     }
     // does not assign offset to the new items.

package/util/check/typecheck.js

@@ -2,7 +2,7 @@
 const doesOwnProperties = (properties, errorMessage) => {
     return (object) => {
         properties.forEach(element => {
-            if (!Object.hasOwn(object, element))
+            if (!object.hasOwnProperty(element))
                 throw new TypeError(errorMessage + ':' + element);
         });
     };
@@ -38,3 +38,17 @@ export const isBoolean = (x) => {
     if (typeof x !== "boolean")
         throw new TypeError("type must be boolean");
 };
+export const mapGetOrThrow = (errorNote) => {
+    return (mapInstance, ids) => {
+        if (!ids)
+            throw new Error("There is no map keys to get");
+        const result = [];
+        for (let i = 0; i < ids.length; i++) {
+            const e = mapInstance.get(ids[i]);
+            if (e === undefined)
+                throw new Error(errorNote + " " + ids[i]);
+            result.push(e);
+        }
+        return result;
+    };
+};

package/util/geometry/index.js

@@ -24,8 +24,9 @@ function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
 }
 /**
  *
- * @param {Float32List} array
- * @returns {Float32Array}
+ * @param array - The array to normalize
+ * @param newLength - The target length for the normalized array
+ * @returns Normalized Float32Array
  */
 function normalize(array, newLength = 1) {
     let total = 0;

package/util/gl-util/buffer/attribute-loader.js

@@ -1,4 +1,3 @@
-import './types';
 /**
  * @typedef BufferAndReadInfo Buffers can be intertwined or interleaved.
  * This object forces user to adapt generic convention of buffer and read information.
@@ -20,10 +19,8 @@ import './types';
  * @returns
  */
 const attributeLoader = (gl, bufferAndReadInfo, index, size, { divisor = null, type = null, escapeValues = null, normalized = false } = {}) => {
-    if (size < 1 || size > 4)
-        throw new Error("Size must be between 1 and 4");
-    if (bufferAndReadInfo == null) {
-        if (escapeValues !== null)
+    if (bufferAndReadInfo == null || bufferAndReadInfo.buffer == null) {
+        if (escapeValues)
             constantFunction(gl, index, size, escapeValues);
         return;
     }

package/util/gl-util/draw-options/methods.js

@@ -1,17 +1,16 @@
-import './types';
 /**
  * Draws instanced geometry using WebGL2.
  */
 const drawInstanced = (gl, mode, drawOptions, vertexCount) => {
     const { drawRange, elementBufferIndexType = gl.UNSIGNED_INT } = drawOptions;
-    const { first = 0, count: instanceCount = 1 } = drawRange;
-    if (first > 0 || drawOptions.elementBuffer) {
+    const { first = 0, count } = drawRange;
+    if (drawOptions.elementBuffer) {
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, drawOptions.elementBuffer ?? null);
-        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, instanceCount);
+        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, count);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
     }
     else {
-        gl.drawArraysInstanced(mode, first, vertexCount, instanceCount);
+        gl.drawArraysInstanced(mode, first, vertexCount, count);
     }
 };
 /**

package/util/webglobjectbuilders.js

@@ -34,8 +34,7 @@ export function createShader(gl, type, source) {
 export function createProgram(gl, vertexSource, fragmentSource) {
     const program = gl.createProgram();
     if (!program) {
-        console.error("Failed to create WebGLProgram.");
-        return undefined;
+        throw new Error("Failed to create WebGLProgram.");
     }
     let vertexShader;
     let fragmentShader;
@@ -45,18 +44,14 @@ export function createProgram(gl, vertexSource, fragmentSource) {
     }
     catch (e) { // Catching errors from createShader
         console.error(e.message);
-        gl.deleteProgram(program); // Clean up the program if shaders failed
-        return undefined;
+        throw new Error(`Shader creation failed: ${e.message}`);
     }
     gl.attachShader(program, vertexShader);
     gl.attachShader(program, fragmentShader);
     gl.linkProgram(program);
     if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-        console.error("Failed to link WebGL program:", gl.getProgramInfoLog(program));
-        gl.deleteProgram(program);
-        gl.deleteShader(vertexShader);
-        gl.deleteShader(fragmentShader);
-        return undefined;
+        // console.error("Failed to link WebGL program:", gl.getProgramInfoLog(program));
+        throw new Error(`Error linking program:\n${gl.getProgramInfoLog(program)}`);
     }
     // Detach and delete shaders after linking to free up resources
     gl.detachShader(program, vertexShader);
@@ -217,7 +212,7 @@ export function decodeBase64(data) {
  */
 export function createImageFromBase64(encodedData) {
     const bytes = decodeBase64(encodedData);
-    const blob = new Blob([bytes.buffer], { type: "image/png" });
+    const blob = new Blob([bytes], { type: "image/png" });
     const urlCreator = window.URL || window.webkitURL;
     const imageUrl = urlCreator.createObjectURL(blob);
     const image = new Image();

package/write-text/context-text3.js

@@ -1,3 +1,4 @@
+// @ts-ignore
 import { CSZMode } from "@pirireis/webglobe";
 import { isTextFont, opacityCheck } from "../util/check/typecheck";
 /**
@@ -9,6 +10,22 @@ import { isTextFont, opacityCheck } from "../util/check/typecheck";
  * TODO: key check and raise error if doesnt exist
  */
 export class ContextTextWriter3 {
+    globe;
+    itemMap;
+    // @ts-ignore
+    style;
+    doDraw;
+    textAdaptor;
+    coordinatesAdaptor;
+    keyAdaptor;
+    zoomLevelAdaptor;
+    positionAdaptor;
+    opacityAdaptor;
+    angleOnSphere;
+    angleAdaptor;
+    angleAdaptorIsOn;
+    xOffset;
+    yOffset;
     constructor(globe, { style = {
         textFont: {
             name: 'Arial',

package/write-text/context-text3old.js

@@ -0,0 +1,152 @@
+"use strict";
+// import { CSZMode } from "@pirireis/webglobe";
+// import { isTextFont, opacityCheck } from "../util/check/typecheck";
+// /**
+//  * TODOs:
+//  * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+//  * 2) expose a mechanic to update text on zoom change
+//  * 3) extend the mechanic on 2 to other events
+//  *
+//  * TODO: key check and raise error if doesnt exist
+//  */
+// export class ContextTextWriter3 {
+//     constructor(globe, {
+//         style = {
+//             textFont: {
+//                 name: 'Arial',
+//                 textColor: '#FFFFFF', // beyaz
+//                 hollowColor: '#000000', // siyah
+//                 size: 12, // piksel
+//                 hollow: true,
+//                 bold: true,
+//                 italic: false,
+//             },
+//             opacity: 1.0,
+//             zMode: CSZMode.Z_GROUND_PERVERTEX,
+//         },
+//         xOffset = 0,
+//         yOffset = 0,
+//         doDraw = true,
+//         textAdaptor = null,
+//         coordinatesAdaptor = null,
+//         keyAdaptor = null,
+//         opacityAdaptor = null,
+//         angleAdaptor = null,
+//         angleOnSphere = false,
+//         positionAdaptor = (item, i, container, properties) => "left",
+//         zoomLevelAdaptor = (zoomLevel) => (item) => {
+//             return {
+//                 opacityMultiplier: 1,
+//                 sizeMultiplier: 1
+//             }
+//         }
+//     } = {}) {
+//         this.globe = globe;
+//         this.itemMap = new Map();
+//         this.setStyle(style);
+//         this.doDraw = doDraw;
+//         this._checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset);
+//         this.textAdaptor = textAdaptor;
+//         this.coordinatesAdaptor = coordinatesAdaptor;
+//         this.keyAdaptor = keyAdaptor;
+//         this.zoomLevelAdaptor = zoomLevelAdaptor;
+//         this.positionAdaptor = positionAdaptor;
+//         this.opacityAdaptor = opacityAdaptor ? opacityAdaptor : () => 1;
+//         this.angleOnSphere = angleOnSphere;
+//         if (angleAdaptor) {
+//             this.angleAdaptor = angleAdaptor
+//             this.angleAdaptorIsOn = true;
+//         } else {
+//             this.angleAdaptor = () => null
+//             this.angleAdaptorIsOn = false
+//         }
+//         this.xOffset = xOffset;
+//         this.yOffset = yOffset;
+//     }
+//     _checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset) {
+//         if (textAdaptor !== null) if (!(textAdaptor instanceof Function)) throw new Error("textAdaptor is not an instance of a Function");
+//         if (coordinatesAdaptor !== null) if (!(coordinatesAdaptor instanceof Function)) throw new Error("coordinatesAdaptor is not an instance of a Function");
+//         if (keyAdaptor !== null) if (!(keyAdaptor instanceof Function)) throw new Error("keyAdaptor is not an instance of a Function");
+//         if (opacityAdaptor !== null) if (!(opacityAdaptor instanceof Function)) throw new Error("opacityAdaptor is not an instance of a Function");
+//         if (angleAdaptor !== null) if (!(angleAdaptor instanceof Function)) throw new Error("angleAdaptor is not an instance of a Function");
+//         if (typeof xOffset !== "number") throw new Error("xOffset type is not a number");
+//         if (typeof yOffset !== "number") throw new Error("yOffset type is not a number");
+//     }
+//     setKeyAdaptor(adaptor) {
+//         this.keyAdaptor = adaptor;
+//     }
+//     setDoDraw(bool) {
+//         this.doDraw = bool;
+//         this.globe.DrawRender();
+//     }
+//     setStyle(style) {
+//         isTextFont(style.textFont);
+//         opacityCheck(style.opacity); //TODO: use shallow copy
+//         this.style = style;
+//         this.globe.DrawRender();
+//     }
+//     setOpacity(opacity) {
+//         this.style.opacity = opacity;
+//         this.globe.DrawRender();
+//     }
+//     draw() {
+//         if (!this.doDraw) return;
+//         const { globe, style, itemMap, xOffset, yOffset } = this;
+//         const { textFont, opacity: opacity_ } = style;
+//         const textSize = textFont.size;
+//         const is3D = globe.api_GetCurrentGeometry() === 0;
+//         const angleIsOn = is3D ? (this.angleAdaptorIsOn && this.angleOnSphere) : (this.angleAdaptorIsOn)
+//         const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+//         const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
+//         for (const item of itemMap.values()) {
+//             const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+//             const { x, y } = globe.api_GetScreenPointFromGeo(
+//                 {
+//                     long: long,
+//                     lat: lat,
+//                     z: 0,
+//                 },
+//                 style.zMode === CSZMode.Z_MSL,
+//             );
+//             const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(zPayload);
+//             const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
+//             textFont.size = sizeMultiplier * textSize;
+//             textFont.position = position;
+//             if (x !== null && y !== null) globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+//         }
+//         textFont.size = textSize;
+//     }
+//     insertTextBulk(container, properties) {
+//         container.forEach((v, i, c) => {
+//             this.insertText(v, i, c, properties);
+//         });
+//     }
+//     deleteTextBulk(keys) {
+//         for (const key of keys) {
+//             this.itemMap.delete(key);
+//         }
+//     }
+//     insertText(item, id, container, properties) {
+//         const key = this.keyAdaptor(item, id, container, properties)
+//         const coords = this.coordinatesAdaptor(item, id, container, properties)
+//         if (coords == null) {
+//             this.itemMap.delete(key);
+//             return;
+//         }
+//         const text = this.textAdaptor(item, id, container, properties)
+//         if (text == null) {
+//             this.itemMap.delete(key);
+//             return
+//         };
+//         const opacity = this.opacityAdaptor(item, id, container, properties);
+//         const angle = this.angleAdaptor(item, id, container, properties);
+//         const position = this.positionAdaptor(item, id, container, properties);
+//         this.itemMap.set(key, { long: coords.long, lat: coords.lat, text, opacity, angle, zPayload: item, position });
+//     }
+//     clear() {
+//         this.itemMap.clear();
+//     }
+//     free() {
+//         this.itemMap = null;
+//     }
+// }