@openglobus/og 0.22.2 → 0.24.0

package/lib/js/utils/objParser.js

@@ -1,179 +1,271 @@
-export function objParser(text) {
-    const objPositions = [[0, 0, 0]];
-    const objTexcoords = [[0, 0]];
-    const objNormals = [[0, 0, 0]];
-    // same order as `f` indices
-    const objVertexData = [
-        objPositions,
-        objTexcoords,
-        objNormals,
-    ];
-    // same order as `f` indices
-    let vertexData = [
-        [], // positions
-        [], // texcoords
-        [], // normals
-    ];
-    const materialLibs = [];
-    const geometries = [];
-    let geometry;
-    let groups = ['default'];
-    let material = 'default';
-    let object = 'default';
-    function newGeometry() {
+function getTexturePath(path) {
+    let p = path.split('/');
+    let filename = p[p.length - 1];
+    let folder = p[p.length - 2];
+    return `${folder ? folder + "/" : ""}${filename}`;
+}
+export class Obj {
+    constructor() {
+        this.objPositions = [];
+        this.objTexcoords = [];
+        this.objNormals = [];
+        // same order as `f` indices
+        this.objVertexData = [
+            this.objPositions,
+            this.objTexcoords,
+            this.objNormals,
+        ];
+        // same order as `f` indices
+        this.vertexData = [
+            [], // positions
+            [], // texcoords
+            [], // normals
+        ];
+        this._materialLibs = [];
+        this.geometries = [];
+        this.geometry = null;
+        this.materials = {};
+        this.material = {};
+        this.object = 'default';
+        this.groups = ['default'];
+        this._path = "";
+        this.keywords = {
+            v: (parts) => {
+                this.objPositions.push(parts.map(parseFloat));
+            },
+            vn: (parts) => {
+                this.objNormals.push(parts.map(parseFloat));
+            },
+            vt: (parts) => {
+                // should check for missing v and extra w?
+                this.objTexcoords.push([parseFloat(parts[0]), 1.0 - parseFloat(parts[1])]);
+            },
+            f: (parts) => {
+                this.setGeometry();
+                const numTriangles = parts.length - 2;
+                for (let tri = 0; tri < numTriangles; ++tri) {
+                    this.addVertex(parts[0]);
+                    this.addVertex(parts[tri + 1]);
+                    this.addVertex(parts[tri + 2]);
+                }
+            },
+            s: () => {
+                // skip texture scale
+            },
+            mtllib: (parts, unparsedArgs) => {
+                // the spec says there can be multiple filenames here
+                // but many exist with spaces in a single filename
+                this._materialLibs.push(unparsedArgs);
+            },
+            usemtl: (parts, unparsedArgs) => {
+                this.newGeometry();
+                this.setGeometry();
+                if (this.geometry) {
+                    this.geometry.material = unparsedArgs;
+                }
+            },
+            g: (parts) => {
+                this.groups = parts;
+                this.newGeometry();
+            },
+            o: (parts, unparsedArgs) => {
+                this.object = unparsedArgs;
+                this.newGeometry();
+            },
+            newmtl: (parts, unparsedArgs) => {
+                const material = {};
+                this.material = material;
+                this.materials[unparsedArgs] = material;
+            },
+            Ns: (parts, unparsedArgs) => {
+                this.material.shininess = parseFloat(unparsedArgs);
+            },
+            Ni: (parts, unparsedArgs) => {
+                // skip refraction
+            },
+            Ka: (parts, unparsedArgs) => {
+                this.material.ambient = parts.map(v => parseFloat(v));
+            },
+            Kd: (parts, unparsedArgs) => {
+                this.material.diffuse = parts.map(v => parseFloat(v));
+            },
+            Ks: (parts, unparsedArgs) => {
+                this.material.specular = parts.map(v => parseFloat(v));
+            },
+            Ke: (parts, unparsedArgs) => {
+                this.material.color = parts.map(v => parseFloat(v));
+            },
+            illum: (parts, unparsedArgs) => {
+                this.material.illum = parseFloat(unparsedArgs);
+            },
+            d: (parts, unparsedArgs) => {
+                this.material.opacity = parseFloat(unparsedArgs);
+            },
+            Tr: (parts, unparsedArgs) => {
+                this.material.opacity = parseFloat(unparsedArgs);
+            },
+            Tf: (parts, unparsedArgs) => {
+                // skip transmission filter
+            },
+            map_Ka: (parts, unparsedArgs) => {
+                // skip ambient texture
+            },
+            map_Kd: (parts, unparsedArgs) => {
+                this.material.colorTexture = `${this._path}/${getTexturePath(unparsedArgs)}`;
+            },
+            map_Bump: (parts, unparsedArgs) => {
+                this.material.normalTexture = `${this._path}/${getTexturePath(unparsedArgs)}`;
+            },
+            map_Ns: (parts, unparsedArgs) => {
+                this.material.metallicRoughnessTexture = `${this._path}/${getTexturePath(unparsedArgs)}`;
+            },
+        };
+    }
+    newGeometry() {
         // If there is an existing geometry and it's
         // not empty then start a new one.
-        if (geometry && geometry.data.vertices.length) {
-            geometry = null;
+        if (this.geometry && this.geometry.data.vertices.length) {
+            this.geometry = null;
         }
     }
-    function setGeometry() {
-        if (!geometry) {
+    setGeometry() {
+        if (!this.geometry) {
             const vertices = [];
-            const textures = [];
+            const texCoords = [];
             const normals = [];
-            vertexData = [
+            this.vertexData = [
                 vertices,
-                textures,
+                texCoords,
                 normals,
             ];
-            geometry = {
-                object,
-                groups,
-                material,
+            this.geometry = {
+                object: this.object,
+                groups: this.groups,
+                material: "",
                 data: {
                     vertices,
-                    textures,
+                    texCoords,
                     normals,
                 },
             };
-            geometries.push(geometry);
+            this.geometries.push(this.geometry);
         }
     }
-    function addVertex(vert) {
-        const ptn = vert.split('/');
-        ptn.forEach((objIndexStr, i) => {
+    addVertex(vert) {
+        let ptn = vert.split('/');
+        for (let i = 0; i < ptn.length; i++) {
+            let objIndexStr = ptn[i];
             if (!objIndexStr) {
-                return;
+                continue;
             }
-            const objIndex = parseInt(objIndexStr);
-            const index = objIndex + (objIndex >= 0 ? 0 : objVertexData[i].length);
-            vertexData[i].push(...objVertexData[i][index]);
-        });
-    }
-    const keywords = {
-        v(parts) {
-            objPositions.push(parts.map(parseFloat));
-        },
-        vn(parts) {
-            objNormals.push(parts.map(parseFloat));
-        },
-        vt(parts) {
-            // should check for missing v and extra w?
-            objTexcoords.push(parts.map(parseFloat));
-        },
-        f(parts) {
-            setGeometry();
-            const numTriangles = parts.length - 2;
-            for (let tri = 0; tri < numTriangles; ++tri) {
-                addVertex(parts[0]);
-                addVertex(parts[tri + 1]);
-                addVertex(parts[tri + 2]);
+            let index = parseInt(objIndexStr) - 1;
+            let v = this.vertexData[i];
+            let len = v.length;
+            let d = this.objVertexData[i][index];
+            let dlen = d.length;
+            this.vertexData[i].length = len + dlen;
+            for (let j = 0; j < dlen; j++) {
+                v[len + j] = d[j];
             }
-        },
-        s: () => {
-        }, // smoothing group
-        mtllib(parts, unparsedArgs) {
-            // the spec says there can be multiple filenames here
-            // but many exist with spaces in a single filename
-            materialLibs.push(unparsedArgs);
-        },
-        usemtl(parts, unparsedArgs) {
-            material = unparsedArgs;
-            newGeometry();
-        },
-        g(parts) {
-            groups = parts;
-            newGeometry();
-        },
-        o(parts, unparsedArgs) {
-            object = unparsedArgs;
-            newGeometry();
-        },
-    };
-    const keywordRE = /(\w*)(?: )*(.*)/;
-    const lines = text.split('\n');
-    for (let lineNo = 0; lineNo < lines.length; ++lineNo) {
-        const line = lines[lineNo].trim();
-        if (line === '' || line.startsWith('#')) {
-            continue;
         }
-        const m = keywordRE.exec(line);
-        if (!m) {
-            continue;
-        }
-        const [, keyword, unparsedArgs] = m;
-        const parts = line.split(/\s+/).slice(1);
-        const handler = keywords[keyword];
-        if (!handler) {
-            console.warn('unhandled keyword:', keyword); // eslint-disable-line no-console
-            continue;
+    }
+    _innerParser(text, fileName) {
+        const keywordRE = /(\w*)(?: )*(.*)/;
+        const lines = text.split('\n');
+        for (let lineNo = 0; lineNo < lines.length; ++lineNo) {
+            const line = lines[lineNo].trim();
+            if (line === '' || line.startsWith('#')) {
+                continue;
+            }
+            const m = keywordRE.exec(line);
+            if (!m) {
+                continue;
+            }
+            const [, keyword, unparsedArgs] = m;
+            const parts = line.split(/\s+/).slice(1);
+            const handler = this.keywords[keyword];
+            if (!handler) {
+                console.warn(`Unknown keyword '${keyword}' in '${fileName}:${lineNo}'`); // eslint-disable-line no-console
+                continue;
+            }
+            handler(parts, unparsedArgs);
         }
-        handler(parts, unparsedArgs);
     }
-    // remove any arrays that have no entries.
-    for (const geometry of geometries) {
-        geometry.data = Object.fromEntries(Object.entries(geometry.data).filter(([key, array]) => array.length > 0));
+    get data() {
+        return {
+            geometries: this.geometries,
+            materials: this.materials
+        };
     }
-    return {
-        geometries,
-        materialLibs,
-    };
-}
-export function transformLeftToRightCoordinateSystem(objData) {
-    const convertedGeometries = objData.geometries.map(geometry => {
-        const vertices = geometry.data.vertices;
-        const normals = geometry.data.normals;
-        const textures = geometry.data.textures;
-        rotateObject(geometry.data, 0);
-        let convertedVertices = [];
-        let convertedNormals = [];
-        let convertedTextures = [];
-        // Convert positions
-        for (let i = 0; i < vertices.length; i += 3) {
-            const x = vertices[i];
-            const y = vertices[i + 1];
-            const z = vertices[i + 2];
-            convertedVertices.push(x, y, z);
+    async load(src) {
+        this._path = src.substring(0, src.lastIndexOf("/"));
+        const response = await fetch(src);
+        if (!response.ok) {
+            throw new Error(`Unable to load '${src}'`);
         }
-        // Convert normals
-        for (let i = 0; i < normals.length; i += 3) {
-            const x = normals[i];
-            const y = normals[i + 1];
-            const z = normals[i + 2];
-            convertedNormals.push(x, y, -z);
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let { value, done } = await reader.read();
+        let partialLine = '';
+        while (!done) {
+            const text = decoder.decode(value, { stream: true });
+            const lines = (partialLine + text).split('\n');
+            partialLine = lines.pop();
+            for (const line of lines) {
+                this._innerParser(line, src);
+            }
+            ({ value, done } = await reader.read());
         }
-        // Convert textures
-        for (let i = 0; i < textures.length; i += 2) {
-            const s = textures[i];
-            const t = 1 - textures[i + 1];
-            convertedTextures.push(s, t);
+        if (partialLine) {
+            this._innerParser(partialLine, src);
         }
-        return {
-            object: geometry.object,
-            groups: geometry.groups,
-            material: geometry.material,
-            data: {
-                vertices: convertedVertices,
-                normals: convertedNormals,
-                textures: convertedTextures
+        this._cleanupGeometryArrays();
+        let defArr = this._materialLibs.map(filename => {
+            filename = `${this._path}/${filename}`;
+            return fetch(filename)
+                .then((response) => response.text())
+                .then((text) => {
+                return { text, filename };
+            });
+        });
+        await Promise.all(defArr).then((mtlArr) => {
+            mtlArr.forEach(mtl => this._innerParser(mtl.text, mtl.filename));
+        });
+        return this.data;
+    }
+    async _readAndParse(file) {
+        const stream = file.stream();
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let { value, done } = await reader.read();
+        let partialLine = "";
+        while (!done) {
+            const text = decoder.decode(value, { stream: true });
+            const lines = (partialLine + text).split("\n");
+            partialLine = lines.pop();
+            for (const line of lines) {
+                this._innerParser(line, file.name);
             }
-        };
-    });
-    return {
-        geometries: convertedGeometries,
-        materialLibs: objData.materialLibs
-    };
+            ({ value, done } = await reader.read());
+        }
+        if (partialLine) {
+            this._innerParser(partialLine, file.name);
+        }
+    }
+    async readFile(objFile, mtlFile) {
+        this._path = "";
+        await this._readAndParse(objFile);
+        this._cleanupGeometryArrays();
+        if (mtlFile) {
+            await this._readAndParse(mtlFile);
+        }
+        return this.data;
+    }
+    _cleanupGeometryArrays() {
+        for (const geometry of this.geometries) {
+            geometry.data = Object.fromEntries(Object.entries(geometry.data).filter(([key, array]) => array.length > 0));
+        }
+    }
 }
 function rotateObject(obj, angle) {
     const cosA = Math.cos(angle);

package/lib/js/utils/shared.d.ts

@@ -7,6 +7,7 @@ import { Vec2 } from "../math/Vec2";
 import { NumberArray2 } from "../math/Vec2";
 import { NumberArray3, Vec3 } from "../math/Vec3";
 import { NumberArray4, Vec4 } from "../math/Vec4";
+import { Ellipsoid } from "../ellipsoid/Ellipsoid";
 export declare function getDefault(param?: any, def?: any): boolean;
 export declare function isEmpty(v: any): boolean;
 /**
@@ -261,3 +262,24 @@ export declare function isImageLoaded(image: HTMLImageElement): boolean;
 export declare function distanceFormat(v: number): string;
 export declare function distanceFormatExt(v: number): [string, string];
 export declare function getUrlParam(paramName: string): number | undefined;
+/**
+ *
+ * @param x
+ * @param y
+ * @param z
+ * @param imageSize
+ * @param ellipsoid
+ *
+ * console.log(1, getTileImageResolution(0, 0, 1));
+ * console.log(7, getTileImageResolution(66, 44, 7));
+ * console.log(10, getTileImageResolution(536, 358, 10));
+ * console.log(12, getTileImageResolution(2149, 1446, 12));
+ * console.log(13, getTileImageResolution(4301, 2892, 13));
+ * console.log(14, getTileImageResolution(8582, 5736, 14));
+ * console.log(15, getTileImageResolution(17205, 11569, 15));
+ * console.log(16, getTileImageResolution(34419, 23138, 16));
+ * console.log(17, getTileImageResolution(68661, 45892, 17));
+ * console.log(18, getTileImageResolution(137650, 92555, 18));
+ */
+export declare function getTileImageResolution(x: number, y: number, z: number, imageSize?: number, ellipsoid?: Ellipsoid): number[];
+export declare function toFixedMax(value: number, maxFixed?: number): string;

package/lib/js/utils/shared.js

@@ -7,6 +7,8 @@ import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Vec4 } from "../math/Vec4";
 import { colorTable } from "./colorTable";
+import { wgs84 } from "../ellipsoid/wgs84";
+import * as mercator from "../mercator";
 export function getDefault(param, def) {
     return param != undefined ? param : def;
 }
@@ -925,3 +927,35 @@ export function getUrlParam(paramName) {
         return Number(param);
     }
 }
+/**
+ *
+ * @param x
+ * @param y
+ * @param z
+ * @param imageSize
+ * @param ellipsoid
+ *
+ * console.log(1, getTileImageResolution(0, 0, 1));
+ * console.log(7, getTileImageResolution(66, 44, 7));
+ * console.log(10, getTileImageResolution(536, 358, 10));
+ * console.log(12, getTileImageResolution(2149, 1446, 12));
+ * console.log(13, getTileImageResolution(4301, 2892, 13));
+ * console.log(14, getTileImageResolution(8582, 5736, 14));
+ * console.log(15, getTileImageResolution(17205, 11569, 15));
+ * console.log(16, getTileImageResolution(34419, 23138, 16));
+ * console.log(17, getTileImageResolution(68661, 45892, 17));
+ * console.log(18, getTileImageResolution(137650, 92555, 18));
+ */
+export function getTileImageResolution(x, y, z, imageSize = 256, ellipsoid = wgs84) {
+    let ext = mercator.getTileExtent(x, y, z);
+    let b0 = ext.getSouthWest().inverseMercator(), b1 = ext.getNorthEast().inverseMercator();
+    let width = ellipsoid.getGreatCircleDistance(b0, new LonLat(b1.lon, b0.lat)), height = ellipsoid.getGreatCircleDistance(b0, new LonLat(b0.lon, b1.lat));
+    return [width / imageSize, height / imageSize];
+}
+export function toFixedMax(value, maxFixed = -1) {
+    if (maxFixed < 0) {
+        return value.toString();
+    }
+    const factor = Math.pow(10, maxFixed);
+    return (Math.round(value * factor) / factor).toString();
+}

package/lib/js/webgl/BaseFramebuffer.d.ts

@@ -1,6 +1,5 @@
 import { Handler } from "./Handler";
 export interface IBaseFramebufferParams {
-    internalFormat?: string | string[];
     width?: number;
     height?: number;
     useDepth?: boolean;

package/lib/js/webgl/Framebuffer.d.ts

@@ -1,13 +1,37 @@
 import { BaseFramebuffer, IBaseFramebufferParams } from "./BaseFramebuffer";
 import { Handler } from "./Handler";
+import { TypedArray } from "../utils/shared";
+export interface ITargetParams {
+    internalFormat?: string;
+    format?: string;
+    type?: string;
+    attachment?: string;
+    filter?: string;
+    readAsync?: boolean;
+}
 export interface IFrameBufferParams extends IBaseFramebufferParams {
     isBare?: boolean;
-    format?: string | string[];
-    type?: string | string[];
-    attachment?: string | string[];
     renderbufferTarget?: string;
     textures?: WebGLTexture[];
+    targets?: ITargetParams[];
+}
+type TypedArrayConstructor = Uint8ArrayConstructor | Float32ArrayConstructor;
+interface ITarget {
+    internalFormat: string;
+    format: string;
+    type: string;
+    attachment: string;
+    filter: string;
+    pixelBufferIndex: number;
+    TypeArrayConstructor: TypedArrayConstructor;
+}
+interface IPixelBuffer {
+    buffer: WebGLBuffer | null;
+    data: TypedArray | null;
+    glType: number;
+    glAttachment: number;
 }
+export declare function clientWaitAsync(gl: WebGL2RenderingContext, sync: WebGLSync, flags: number): Promise<void>;
 /**
  * Class represents framebuffer.
  * @class
@@ -15,19 +39,18 @@ export interface IFrameBufferParams extends IBaseFramebufferParams {
  * @param {IFrameBufferParams} [options] - Framebuffer options:
  */
 export declare class Framebuffer extends BaseFramebuffer {
-    protected _isBare: boolean;
-    protected _internalFormatArr: string[];
-    protected _formatArr: string[];
-    protected _typeArr: string[];
-    protected _attachmentArr: string[];
     protected _renderbufferTarget: string;
+    protected _targets: ITarget[];
     /**
      * Framebuffer texture.
      * @public
      * @type {number}
      */
     textures: WebGLTexture[];
+    pixelBuffers: IPixelBuffer[];
+    protected _skipFrame: boolean;
     constructor(handler: Handler, options?: IFrameBufferParams);
+    static createTargets(targets?: ITargetParams[]): ITarget[];
     destroy(): void;
     /**
      * Framebuffer initialization.
@@ -35,6 +58,9 @@ export declare class Framebuffer extends BaseFramebuffer {
      * @override
      */
     init(): void;
+    readPixelBuffersAsync: () => void;
+    getPixelBufferData(targetIndex: number): TypedArray | null;
+    protected _createPixelBuffer(target: ITarget): void;
     /**
      * Bind buffer texture.
      * @public
@@ -67,3 +93,4 @@ export declare class Framebuffer extends BaseFramebuffer {
      */
     getImage(): HTMLImageElement;
 }
+export {};