astro-viewer 3.2.0 → 3.3.0

package/lib-esm/model/meships/MeshHiPSTile.d.ts

@@ -0,0 +1,29 @@
+import { MeshHiPSShaderProgram } from '../../shader/MeshHiPSShaderProgram.js';
+import type { MeshHiPSTileCoord } from './MeshHiPSTypes.js';
+type Mat4 = Float32Array;
+export declare class MeshHiPSTile {
+    readonly coord: MeshHiPSTileCoord;
+    private _url;
+    private _webgl;
+    private _shaderProgram;
+    private _gpuMesh;
+    private _ready;
+    private _loading;
+    private _failed;
+    private _lastUsedAt;
+    private _createdAt;
+    constructor(coord: MeshHiPSTileCoord, _url: string, _webgl: WebGL2RenderingContext, _shaderProgram: MeshHiPSShaderProgram);
+    get ready(): boolean;
+    get loading(): boolean;
+    get failed(): boolean;
+    get lastUsedAt(): number;
+    get createdAt(): number;
+    touch(): void;
+    draw(pMatrix: Mat4, vMatrix: Mat4, mMatrix: Mat4, color: [number, number, number, number], wireframe: boolean): boolean;
+    dispose(): void;
+    private load;
+    private uploadMesh;
+    private buildLineIndices;
+    private get key();
+}
+export {};

package/lib-esm/model/meships/MeshHiPSTile.js

@@ -0,0 +1,148 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ */
+import { OBJMeshParser } from './OBJMeshParser.js';
+export class MeshHiPSTile {
+    coord;
+    _url;
+    _webgl;
+    _shaderProgram;
+    _gpuMesh = null;
+    _ready = false;
+    _loading = false;
+    _failed = false;
+    _lastUsedAt = 0;
+    _createdAt = Date.now();
+    constructor(coord, _url, _webgl, _shaderProgram) {
+        this.coord = coord;
+        this._url = _url;
+        this._webgl = _webgl;
+        this._shaderProgram = _shaderProgram;
+        void this.load();
+    }
+    get ready() {
+        return this._ready;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get failed() {
+        return this._failed;
+    }
+    get lastUsedAt() {
+        return this._lastUsedAt;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    touch() {
+        this._lastUsedAt = Date.now();
+    }
+    draw(pMatrix, vMatrix, mMatrix, color, wireframe) {
+        this.touch();
+        if (!this._ready || !this._gpuMesh)
+            return false;
+        const gl = this._webgl;
+        this._shaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, color);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._gpuMesh.positionBuffer);
+        gl.vertexAttribPointer(this._shaderProgram.locations.vertexPositionAttribute, 3, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(this._shaderProgram.locations.vertexPositionAttribute);
+        if (this._shaderProgram.locations.vertexNormalAttribute >= 0) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._gpuMesh.normalBuffer);
+            gl.vertexAttribPointer(this._shaderProgram.locations.vertexNormalAttribute, 3, gl.FLOAT, false, 0, 0);
+            gl.enableVertexAttribArray(this._shaderProgram.locations.vertexNormalAttribute);
+        }
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, wireframe ? this._gpuMesh.lineIndexBuffer : this._gpuMesh.indexBuffer);
+        gl.drawElements(wireframe ? gl.LINES : gl.TRIANGLES, wireframe ? this._gpuMesh.lineIndexCount : this._gpuMesh.indexCount, this._gpuMesh.indexType, 0);
+        gl.disableVertexAttribArray(this._shaderProgram.locations.vertexPositionAttribute);
+        if (this._shaderProgram.locations.vertexNormalAttribute >= 0) {
+            gl.disableVertexAttribArray(this._shaderProgram.locations.vertexNormalAttribute);
+        }
+        return true;
+    }
+    dispose() {
+        const gl = this._webgl;
+        if (this._gpuMesh?.positionBuffer)
+            gl.deleteBuffer(this._gpuMesh.positionBuffer);
+        if (this._gpuMesh?.normalBuffer)
+            gl.deleteBuffer(this._gpuMesh.normalBuffer);
+        if (this._gpuMesh?.indexBuffer)
+            gl.deleteBuffer(this._gpuMesh.indexBuffer);
+        if (this._gpuMesh?.lineIndexBuffer)
+            gl.deleteBuffer(this._gpuMesh.lineIndexBuffer);
+        this._gpuMesh = null;
+        this._ready = false;
+        this._loading = false;
+    }
+    async load() {
+        if (this._loading || this._ready)
+            return;
+        this._loading = true;
+        try {
+            const resp = await fetch(this._url);
+            if (!resp.ok)
+                throw new Error(`HTTP ${resp.status} fetching ${this._url}`);
+            const mesh = OBJMeshParser.parse(await resp.text());
+            this._gpuMesh = this.uploadMesh(mesh);
+            this._ready = true;
+            this._failed = false;
+        }
+        catch (error) {
+            console.warn('[MeshHiPSTile] load failed', this._url, error);
+            this._failed = true;
+            this._ready = false;
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    uploadMesh(mesh) {
+        const gl = this._webgl;
+        const positionBuffer = gl.createBuffer();
+        const normalBuffer = gl.createBuffer();
+        const indexBuffer = gl.createBuffer();
+        const lineIndexBuffer = gl.createBuffer();
+        if (!positionBuffer || !normalBuffer || !indexBuffer || !lineIndexBuffer) {
+            throw new Error(`Could not create MeshHiPS buffers for ${this.key}`);
+        }
+        const lineIndices = this.buildLineIndices(mesh.indices);
+        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, mesh.positions, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, normalBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, mesh.normals, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, mesh.indices, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, lineIndexBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, lineIndices, gl.STATIC_DRAW);
+        return {
+            positionBuffer,
+            normalBuffer,
+            indexBuffer,
+            lineIndexBuffer,
+            indexCount: mesh.indices.length,
+            lineIndexCount: lineIndices.length,
+            indexType: gl.UNSIGNED_INT,
+        };
+    }
+    buildLineIndices(indices) {
+        const lines = new Uint32Array(indices.length * 2);
+        let out = 0;
+        for (let i = 0; i < indices.length; i += 3) {
+            const a = indices[i];
+            const b = indices[i + 1];
+            const c = indices[i + 2];
+            lines[out++] = a;
+            lines[out++] = b;
+            lines[out++] = b;
+            lines[out++] = c;
+            lines[out++] = c;
+            lines[out++] = a;
+        }
+        return lines;
+    }
+    get key() {
+        return `${this.coord.order}/${this.coord.ipix}`;
+    }
+}

package/lib-esm/model/meships/MeshHiPSTypes.d.ts

@@ -0,0 +1,41 @@
+export type MeshHiPSTileCoord = {
+    order: number;
+    ipix: number;
+};
+export type MeshHiPSConfig = {
+    baseUrl: string;
+    name?: string;
+    meshRadius?: number;
+    order?: number;
+    minOrder?: number;
+    maxOrder?: number;
+    maxCachedTiles?: number;
+    color?: [number, number, number, number];
+    wireframe?: boolean;
+};
+export type MeshHiPSDebugStats = {
+    activeBaseLayer: 'meships';
+    meshHiPSName: string;
+    meshHiPSUrl: string;
+    currentOrder: number;
+    visibleTileCount: number;
+    coverageTileCount: number;
+    cacheSize: number;
+    readyTileCount: number;
+    loadingTileCount: number;
+    failedTileCount: number;
+};
+export type MeshHiPSMesh = {
+    positions: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+};
+export type MeshHiPSGpuMesh = {
+    positionBuffer: WebGLBuffer | null;
+    normalBuffer: WebGLBuffer | null;
+    indexBuffer: WebGLBuffer | null;
+    lineIndexBuffer: WebGLBuffer | null;
+    indexCount: number;
+    lineIndexCount: number;
+    indexType: number;
+};

package/lib-esm/model/meships/MeshHiPSTypes.js

@@ -0,0 +1,6 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ */
+export {};

package/lib-esm/model/meships/OBJMeshParser.d.ts

@@ -0,0 +1,6 @@
+import type { MeshHiPSMesh } from './MeshHiPSTypes.js';
+export declare class OBJMeshParser {
+    static parse(text: string): MeshHiPSMesh;
+    private static computeVertexNormals;
+    private static resolveIndex;
+}

package/lib-esm/model/meships/OBJMeshParser.js

@@ -0,0 +1,92 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ */
+export class OBJMeshParser {
+    static parse(text) {
+        const vertices = [];
+        const indices = [];
+        const normals = [];
+        const lines = text.split(/\r\n|\n/);
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            if (line.startsWith('v ')) {
+                const parts = line.split(/\s+/);
+                if (parts.length < 4)
+                    continue;
+                vertices.push(Number(parts[1]), Number(parts[2]), Number(parts[3]));
+                normals.push(0, 0, 0);
+                continue;
+            }
+            if (line.startsWith('f ')) {
+                const face = line
+                    .slice(2)
+                    .trim()
+                    .split(/\s+/)
+                    .map((part) => Number(part.split('/')[0]))
+                    .filter((idx) => Number.isInteger(idx) && idx !== 0);
+                if (face.length < 3)
+                    continue;
+                const first = OBJMeshParser.resolveIndex(face[0], vertices.length / 3);
+                for (let i = 1; i < face.length - 1; i++) {
+                    indices.push(first, OBJMeshParser.resolveIndex(face[i], vertices.length / 3), OBJMeshParser.resolveIndex(face[i + 1], vertices.length / 3));
+                }
+            }
+        }
+        OBJMeshParser.computeVertexNormals(vertices, indices, normals);
+        return {
+            positions: new Float32Array(vertices),
+            normals: new Float32Array(normals),
+            indices: new Uint32Array(indices),
+        };
+    }
+    static computeVertexNormals(vertices, indices, normals) {
+        for (let i = 0; i < indices.length; i += 3) {
+            const ia = indices[i];
+            const ib = indices[i + 1];
+            const ic = indices[i + 2];
+            const ax = vertices[ia * 3];
+            const ay = vertices[ia * 3 + 1];
+            const az = vertices[ia * 3 + 2];
+            const bx = vertices[ib * 3];
+            const by = vertices[ib * 3 + 1];
+            const bz = vertices[ib * 3 + 2];
+            const cx = vertices[ic * 3];
+            const cy = vertices[ic * 3 + 1];
+            const cz = vertices[ic * 3 + 2];
+            const abx = bx - ax;
+            const aby = by - ay;
+            const abz = bz - az;
+            const acx = cx - ax;
+            const acy = cy - ay;
+            const acz = cz - az;
+            const nx = aby * acz - abz * acy;
+            const ny = abz * acx - abx * acz;
+            const nz = abx * acy - aby * acx;
+            normals[ia * 3] += nx;
+            normals[ia * 3 + 1] += ny;
+            normals[ia * 3 + 2] += nz;
+            normals[ib * 3] += nx;
+            normals[ib * 3 + 1] += ny;
+            normals[ib * 3 + 2] += nz;
+            normals[ic * 3] += nx;
+            normals[ic * 3 + 1] += ny;
+            normals[ic * 3 + 2] += nz;
+        }
+        for (let i = 0; i < normals.length; i += 3) {
+            const nx = normals[i];
+            const ny = normals[i + 1];
+            const nz = normals[i + 2];
+            const len = Math.hypot(nx, ny, nz) || 1;
+            normals[i] = nx / len;
+            normals[i + 1] = ny / len;
+            normals[i + 2] = nz / len;
+        }
+    }
+    static resolveIndex(objIndex, vertexCount) {
+        return objIndex > 0 ? objIndex - 1 : vertexCount + objIndex;
+    }
+}

package/lib-esm/shader/MeshHiPSShaderProgram.d.ts

@@ -0,0 +1,20 @@
+type MeshHiPSLocations = {
+    pMatrix: WebGLUniformLocation | null;
+    mMatrix: WebGLUniformLocation | null;
+    vMatrix: WebGLUniformLocation | null;
+    color: WebGLUniformLocation | null;
+    vertexPositionAttribute: number;
+    vertexNormalAttribute: number;
+};
+export declare class MeshHiPSShaderProgram {
+    private _webgl;
+    readonly locations: MeshHiPSLocations;
+    private _shaderProgram?;
+    constructor(_webgl: WebGL2RenderingContext);
+    get shaderProgram(): WebGLProgram;
+    enableProgram(): void;
+    enableShaders(pMatrix: Float32Array, vMatrix: Float32Array, mMatrix: Float32Array, color: [number, number, number, number]): void;
+    private initShaders;
+    private compileShader;
+}
+export {};

package/lib-esm/shader/MeshHiPSShaderProgram.js

@@ -0,0 +1,98 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ */
+export class MeshHiPSShaderProgram {
+    _webgl;
+    locations;
+    _shaderProgram;
+    constructor(_webgl) {
+        this._webgl = _webgl;
+        this.locations = {
+            pMatrix: null,
+            mMatrix: null,
+            vMatrix: null,
+            color: null,
+            vertexPositionAttribute: -1,
+            vertexNormalAttribute: -1,
+        };
+    }
+    get shaderProgram() {
+        const gl = this._webgl;
+        if (!this._shaderProgram) {
+            const program = gl.createProgram();
+            if (!program)
+                throw new Error('Could not create MeshHiPS shader program');
+            this._shaderProgram = program;
+            this.initShaders();
+        }
+        gl.useProgram(this._shaderProgram);
+        return this._shaderProgram;
+    }
+    enableProgram() {
+        this._webgl.useProgram(this.shaderProgram);
+    }
+    enableShaders(pMatrix, vMatrix, mMatrix, color) {
+        const gl = this._webgl;
+        const program = this.shaderProgram;
+        gl.useProgram(program);
+        this.locations.pMatrix = gl.getUniformLocation(program, 'uPMatrix');
+        this.locations.vMatrix = gl.getUniformLocation(program, 'uVMatrix');
+        this.locations.mMatrix = gl.getUniformLocation(program, 'uMMatrix');
+        this.locations.color = gl.getUniformLocation(program, 'uColor');
+        this.locations.vertexPositionAttribute = gl.getAttribLocation(program, 'aVertexPosition');
+        this.locations.vertexNormalAttribute = gl.getAttribLocation(program, 'aVertexNormal');
+        gl.uniformMatrix4fv(this.locations.pMatrix, false, pMatrix);
+        gl.uniformMatrix4fv(this.locations.vMatrix, false, vMatrix);
+        gl.uniformMatrix4fv(this.locations.mMatrix, false, mMatrix);
+        gl.uniform4fv(this.locations.color, color);
+    }
+    initShaders() {
+        const gl = this._webgl;
+        const vertexShader = this.compileShader(gl.VERTEX_SHADER, `#version 300 es
+      precision mediump float;
+      in vec3 aVertexPosition;
+      in vec3 aVertexNormal;
+      uniform mat4 uPMatrix;
+      uniform mat4 uVMatrix;
+      uniform mat4 uMMatrix;
+      out vec3 vNormal;
+      void main(void) {
+        vec3 worldPos = (uMMatrix * vec4(aVertexPosition, 1.0)).xyz;
+        vNormal = normalize((uMMatrix * vec4(aVertexNormal, 0.0)).xyz);
+        gl_Position = uPMatrix * uVMatrix * vec4(worldPos, 1.0);
+      }`);
+        const fragmentShader = this.compileShader(gl.FRAGMENT_SHADER, `#version 300 es
+      precision mediump float;
+      in vec3 vNormal;
+      uniform vec4 uColor;
+      out vec4 outColor;
+      void main(void) {
+        vec3 normal = normalize(vNormal);
+        vec3 lightDir = normalize(vec3(0.45, 0.8, 0.35));
+        float diffuse = max(dot(normal, lightDir), 0.0);
+        float rim = pow(1.0 - max(dot(normal, vec3(0.0, 0.0, 1.0)), 0.0), 2.0);
+        vec3 color = uColor.rgb * (0.24 + diffuse * 0.78) + vec3(0.16, 0.24, 0.20) * rim;
+        outColor = vec4(color, uColor.a);
+      }`);
+        gl.attachShader(this._shaderProgram, vertexShader);
+        gl.attachShader(this._shaderProgram, fragmentShader);
+        gl.linkProgram(this._shaderProgram);
+        if (!gl.getProgramParameter(this._shaderProgram, gl.LINK_STATUS)) {
+            throw new Error(gl.getProgramInfoLog(this._shaderProgram) || 'Could not initialise MeshHiPS shaders');
+        }
+    }
+    compileShader(type, source) {
+        const gl = this._webgl;
+        const shader = gl.createShader(type);
+        if (!shader)
+            throw new Error('Could not create MeshHiPS shader');
+        gl.shaderSource(shader, source);
+        gl.compileShader(shader);
+        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+            throw new Error(gl.getShaderInfoLog(shader) || 'MeshHiPS shader compile error');
+        }
+        return shader;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "astro-viewer",
   "description": "Astrobrowser 3d engine.",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "keywords": [
     "HiPS",
     "HiPS cutout",
@@ -48,9 +48,10 @@
     "dev:lib": "tsc -w -p tsconfig.build.json",
     "prod": "npm run clean && tsc -p tsconfig.build.json && webpack --mode=production && npm run web",
     "build": "npm run clean && tsc -p tsconfig.build.json && webpack --mode=production",
-    "web": "cp dist/* public/javascripts/; cp -R src/html/javascripts/ public/javascripts/; cp -R src/html/css/ public/css/; cp src/html/*.html public/",
-    "start-server": "npm run web; python3 -m http.server 8080 -d public",
-    "all": "npm run clean; npm run prod; npm run start-server",
+    "test": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
+    "web": "cp dist/* public/javascripts/ && cp -R src/html/javascripts/ public/javascripts/ && cp -R src/html/css/ public/css/ && cp src/html/*.html public/",
+    "start-server": "npm run build && npm run web && python3 -m http.server 8080 -d public",
+    "all": "npm run start-server",
     "prepublishOnly": "npm run build"
   },
   "engines": {