gridviz 3.0.26 → 3.0.27

package/src/utils/webGLUtils.js

@@ -1,72 +1,72 @@
-//@ts-check
-'use strict'
-
-/**
- * @param {string} width
- * @param {string} height
- * @param {object} opts
- * @returns {{canvas:HTMLCanvasElement, gl:WebGLRenderingContext}}
- */
-export function makeWebGLCanvas(width, height, opts = {}) {
-    const canvas = document.createElement('canvas')
-    canvas.setAttribute('width', width)
-    canvas.setAttribute('height', height)
-    /** @type {WebGLRenderingContext} */
-    const gl = canvas.getContext('webgl', opts)
-    if (!gl) {
-        throw new Error('Unable to initialize WebGL. Your browser or machine may not support it.')
-    }
-    return { canvas: canvas, gl: gl }
-}
-
-/**
- * Initialize a shader program, so WebGL knows how to draw our data
- *
- * @param {WebGLRenderingContext} gl
- * @param  {...WebGLShader} shaders
- * @returns {WebGLProgram}
- */
-export function initShaderProgram(gl, ...shaders) {
-    /** @type {WebGLProgram|null} */
-    const program = gl.createProgram()
-    if (program == null) throw new Error('Cannot create webGL program')
-    for (const shader of shaders) gl.attachShader(program, shader)
-    gl.linkProgram(program)
-    if (gl.getProgramParameter(program, gl.LINK_STATUS)) return program
-    throw new Error(gl.getProgramInfoLog(program) || 'Cannot create webGL program (2)')
-}
-
-/**
- * Creates a shader of the given type, uploads the source and compiles it.
- *
- * @param {WebGLRenderingContext} gl
- * @param {number} type
- * @param  {...string} sources
- * @returns {WebGLShader}
- */
-export function createShader(gl, type, ...sources) {
-    /** @type {WebGLShader|null} */
-    const shader = gl.createShader(type)
-    if (shader == null) throw new Error('Cannot create webGL shader')
-    gl.shaderSource(shader, sources.join('\n'))
-    gl.compileShader(shader)
-    if (gl.getShaderParameter(shader, gl.COMPILE_STATUS)) return shader
-    throw new Error(gl.getShaderInfoLog(shader) || 'Cannot create webGL shader (2)')
-}
-
-/**
- * Check if webGL is supported
- *
- * @returns {boolean}
- */
-export function checkWebGLSupport() {
-    try {
-        const canvas = document.createElement('canvas')
-        return !!(
-            !!window.WebGLRenderingContext &&
-            (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'))
-        )
-    } catch (err) {
-        return false
-    }
-}
+//@ts-check
+'use strict'
+
+/**
+ * @param {string} width
+ * @param {string} height
+ * @param {object} opts
+ * @returns {{canvas:HTMLCanvasElement, gl:WebGLRenderingContext}}
+ */
+export function makeWebGLCanvas(width, height, opts = {}) {
+    const canvas = document.createElement('canvas')
+    canvas.setAttribute('width', width)
+    canvas.setAttribute('height', height)
+    /** @type {WebGLRenderingContext} */
+    const gl = canvas.getContext('webgl', opts)
+    if (!gl) {
+        throw new Error('Unable to initialize WebGL. Your browser or machine may not support it.')
+    }
+    return { canvas: canvas, gl: gl }
+}
+
+/**
+ * Initialize a shader program, so WebGL knows how to draw our data
+ *
+ * @param {WebGLRenderingContext} gl
+ * @param  {...WebGLShader} shaders
+ * @returns {WebGLProgram}
+ */
+export function initShaderProgram(gl, ...shaders) {
+    /** @type {WebGLProgram|null} */
+    const program = gl.createProgram()
+    if (program == null) throw new Error('Cannot create webGL program')
+    for (const shader of shaders) gl.attachShader(program, shader)
+    gl.linkProgram(program)
+    if (gl.getProgramParameter(program, gl.LINK_STATUS)) return program
+    throw new Error(gl.getProgramInfoLog(program) || 'Cannot create webGL program (2)')
+}
+
+/**
+ * Creates a shader of the given type, uploads the source and compiles it.
+ *
+ * @param {WebGLRenderingContext} gl
+ * @param {number} type
+ * @param  {...string} sources
+ * @returns {WebGLShader}
+ */
+export function createShader(gl, type, ...sources) {
+    /** @type {WebGLShader|null} */
+    const shader = gl.createShader(type)
+    if (shader == null) throw new Error('Cannot create webGL shader')
+    gl.shaderSource(shader, sources.join('\n'))
+    gl.compileShader(shader)
+    if (gl.getShaderParameter(shader, gl.COMPILE_STATUS)) return shader
+    throw new Error(gl.getShaderInfoLog(shader) || 'Cannot create webGL shader (2)')
+}
+
+/**
+ * Check if webGL is supported
+ *
+ * @returns {boolean}
+ */
+export function checkWebGLSupport() {
+    try {
+        const canvas = document.createElement('canvas')
+        return !!(
+            !!window.WebGLRenderingContext &&
+            (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'))
+        )
+    } catch (err) {
+        return false
+    }
+}

package/src/utils/zoomUtils.js

@@ -1,142 +1,142 @@
-//@ts-check
-'use strict'
-
-/**
- *
- * @param {import("../App").App} app
- * @param {number} zTarget
- * @param {number} factor
- * @param {number} delayMs
- * @param {function|undefined} callback
- * @param {number} delayBeforeCallBackMs
- * @returns
- */
-export function zoomTo(
-    app,
-    zTarget,
-    factor = 1.01,
-    delayMs = 0,
-    callback = undefined,
-    delayBeforeCallBackMs = 0
-) {
-    //ensure good factor value: >1
-    factor = factor || 1.01
-    if (factor < 1) {
-        console.error('Unexpected value for factor: ' + factor + '. Set to default value 1.01')
-        factor = 1.01
-    }
-
-    const zIni = map.getZoom()
-    if (zTarget == zIni) return
-    if (zTarget < zIni) factor = 1 / factor
-    let z = zIni
-    let timer = setInterval(() => {
-        //compute new zoom level
-        z = map.getZoom() * factor
-        if (zTarget > zIni && z > zTarget) z = zTarget
-        if (zTarget < zIni && z < zTarget) z = zTarget
-
-        //set new zoom level
-        map.setZoom(z)
-        map.redraw()
-
-        //target reached
-        if (z == zTarget) {
-            clearInterval(timer)
-            //trigger callback, if any
-            if (callback)
-                setTimeout(() => {
-                    callback()
-                }, delayBeforeCallBackMs)
-        }
-    }, delayMs)
-    return timer
-}
-
-/**
- *
- * @param {import("../App").App} app
- * @param {number} xTarget
- * @param {number} yTarget
- * @param {number} zTarget
- * @param {number} progressFactorPix
- * @param {number} delayMs
- * @param {function|undefined} callback
- * @param {number} delayBeforeCallBackMs
- * @returns
- */
-export function goToStraight(
-    app,
-    xTarget = NaN,
-    yTarget = NaN,
-    zTarget = NaN,
-    progressFactorPix = 5,
-    delayMs = 0,
-    callback = undefined,
-    delayBeforeCallBackMs = 0
-) {
-    //store initial position/zoom
-    const zIni = map.getZoom()
-    const cIni = map.getView()
-
-    //default
-    xTarget = isNaN(xTarget) ? cIni.x : xTarget
-    yTarget = isNaN(yTarget) ? cIni.y : yTarget
-    zTarget = isNaN(zTarget) ? zIni : zTarget
-
-    //prepare for pan
-    const dx = xTarget - cIni.x
-    const dy = yTarget - cIni.y
-    let d = Math.hypot(dx, dy)
-    const ddx = (progressFactorPix * zIni * dx) / d
-    const ddy = (progressFactorPix * zIni * dy) / d
-
-    //prepare for zoom
-    let r = zTarget / zIni
-    const n = d / (progressFactorPix * zIni)
-    const zoomFactor = d > 0 ? Math.pow(r, 1 / n) : Math.pow(r, 1 / 10) //TODO not 10 ?
-
-    //timer
-    let timer = setInterval(() => {
-        //compute and set new position
-        if (d > 0) {
-            const c = map.getView()
-            let nx = c.x + ddx
-            let ny = c.y + ddy
-            //if went too far, stop at target values
-            if (nx < xTarget && xTarget < c.x) nx = xTarget
-            if (c.x < xTarget && xTarget < nx) nx = xTarget
-            if (ny < yTarget && yTarget < c.y) ny = yTarget
-            if (c.y < yTarget && yTarget < ny) ny = yTarget
-            map.setGeoCenter({ x: nx, y: ny })
-            if (nx == xTarget && ny == yTarget) d = 0
-        }
-
-        //compute and set new zoom
-        if (r != 1) {
-            const z = map.getZoom()
-            let nz = zoomFactor * z
-            //if went too far, stop at target values
-            if (nz < zTarget && zTarget < z) nz = zTarget
-            if (z < zTarget && zTarget < nz) nz = zTarget
-            map.setZoom(nz)
-            if (nz == zTarget) r = 1
-        }
-
-        //redraw
-        map.redraw()
-
-        //if target reached, stop
-        if (d == 0 && r == 1) {
-            //console.log("OK !")
-            clearInterval(timer)
-            //trigger callback, if any
-            if (callback)
-                setTimeout(() => {
-                    callback()
-                }, delayBeforeCallBackMs)
-        }
-    }, delayMs)
-
-    return timer
-}
+//@ts-check
+'use strict'
+
+/**
+ *
+ * @param {import("../App").App} app
+ * @param {number} zTarget
+ * @param {number} factor
+ * @param {number} delayMs
+ * @param {function|undefined} callback
+ * @param {number} delayBeforeCallBackMs
+ * @returns
+ */
+export function zoomTo(
+    app,
+    zTarget,
+    factor = 1.01,
+    delayMs = 0,
+    callback = undefined,
+    delayBeforeCallBackMs = 0
+) {
+    //ensure good factor value: >1
+    factor = factor || 1.01
+    if (factor < 1) {
+        console.error('Unexpected value for factor: ' + factor + '. Set to default value 1.01')
+        factor = 1.01
+    }
+
+    const zIni = map.getZoom()
+    if (zTarget == zIni) return
+    if (zTarget < zIni) factor = 1 / factor
+    let z = zIni
+    let timer = setInterval(() => {
+        //compute new zoom level
+        z = map.getZoom() * factor
+        if (zTarget > zIni && z > zTarget) z = zTarget
+        if (zTarget < zIni && z < zTarget) z = zTarget
+
+        //set new zoom level
+        map.setZoom(z)
+        map.redraw()
+
+        //target reached
+        if (z == zTarget) {
+            clearInterval(timer)
+            //trigger callback, if any
+            if (callback)
+                setTimeout(() => {
+                    callback()
+                }, delayBeforeCallBackMs)
+        }
+    }, delayMs)
+    return timer
+}
+
+/**
+ *
+ * @param {import("../App").App} app
+ * @param {number} xTarget
+ * @param {number} yTarget
+ * @param {number} zTarget
+ * @param {number} progressFactorPix
+ * @param {number} delayMs
+ * @param {function|undefined} callback
+ * @param {number} delayBeforeCallBackMs
+ * @returns
+ */
+export function goToStraight(
+    app,
+    xTarget = NaN,
+    yTarget = NaN,
+    zTarget = NaN,
+    progressFactorPix = 5,
+    delayMs = 0,
+    callback = undefined,
+    delayBeforeCallBackMs = 0
+) {
+    //store initial position/zoom
+    const zIni = map.getZoom()
+    const cIni = map.getView()
+
+    //default
+    xTarget = isNaN(xTarget) ? cIni.x : xTarget
+    yTarget = isNaN(yTarget) ? cIni.y : yTarget
+    zTarget = isNaN(zTarget) ? zIni : zTarget
+
+    //prepare for pan
+    const dx = xTarget - cIni.x
+    const dy = yTarget - cIni.y
+    let d = Math.hypot(dx, dy)
+    const ddx = (progressFactorPix * zIni * dx) / d
+    const ddy = (progressFactorPix * zIni * dy) / d
+
+    //prepare for zoom
+    let r = zTarget / zIni
+    const n = d / (progressFactorPix * zIni)
+    const zoomFactor = d > 0 ? Math.pow(r, 1 / n) : Math.pow(r, 1 / 10) //TODO not 10 ?
+
+    //timer
+    let timer = setInterval(() => {
+        //compute and set new position
+        if (d > 0) {
+            const c = map.getView()
+            let nx = c.x + ddx
+            let ny = c.y + ddy
+            //if went too far, stop at target values
+            if (nx < xTarget && xTarget < c.x) nx = xTarget
+            if (c.x < xTarget && xTarget < nx) nx = xTarget
+            if (ny < yTarget && yTarget < c.y) ny = yTarget
+            if (c.y < yTarget && yTarget < ny) ny = yTarget
+            map.setGeoCenter({ x: nx, y: ny })
+            if (nx == xTarget && ny == yTarget) d = 0
+        }
+
+        //compute and set new zoom
+        if (r != 1) {
+            const z = map.getZoom()
+            let nz = zoomFactor * z
+            //if went too far, stop at target values
+            if (nz < zTarget && zTarget < z) nz = zTarget
+            if (z < zTarget && zTarget < nz) nz = zTarget
+            map.setZoom(nz)
+            if (nz == zTarget) r = 1
+        }
+
+        //redraw
+        map.redraw()
+
+        //if target reached, stop
+        if (d == 0 && r == 1) {
+            //console.log("OK !")
+            clearInterval(timer)
+            //trigger callback, if any
+            if (callback)
+                setTimeout(() => {
+                    callback()
+                }, delayBeforeCallBackMs)
+        }
+    }, delayMs)
+
+    return timer
+}