@cortex-js/compute-engine 0.55.4 → 0.55.5

package/dist/core.umd.cjs

@@ -1,4 +1,4 @@
-/** ComputeEngineCore 0.55.4 */
+/** ComputeEngineCore 0.55.5 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngineCore = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngineCore = (() => {
   var __defProp = Object.defineProperty;
@@ -54810,7 +54810,8 @@ Error in definition of "${name}"`,
         vars: options?.vars,
         imports: options?.imports,
         preamble: options?.preamble,
-        realOnly: options?.realOnly
+        realOnly: options?.realOnly,
+        hints: options?.hints
       });
     } catch (e) {
       if (options?.fallback ?? true) {
@@ -61311,12 +61312,22 @@ Error in definition of "${name}"`,
   }
 
   // src/compute-engine/compilation/fractal-orbit.ts
+  function toBigDecimal(v) {
+    if (typeof v === "object" && "hi" in v)
+      return new BigDecimal(v.hi).add(new BigDecimal(v.lo));
+    return new BigDecimal(v);
+  }
+  function hpToNumber(v) {
+    if (typeof v === "number") return v;
+    if (typeof v === "string") return Number(v);
+    return v.hi + v.lo;
+  }
   function computeReferenceOrbit(center, maxIter, precision) {
     const prevPrecision = BigDecimal.precision;
     BigDecimal.precision = precision;
     try {
-      const cr = new BigDecimal(center[0]);
-      const ci = new BigDecimal(center[1]);
+      const cr = toBigDecimal(center[0]);
+      const ci = toBigDecimal(center[1]);
       let zr = BigDecimal.ZERO;
       let zi = BigDecimal.ZERO;
       const ESCAPE = new BigDecimal(256);
@@ -61924,12 +61935,12 @@ Error in definition of "${name}"`,
       const iterCode = compileIntArg(maxIter, compile3, target);
       const strategy = selectFractalStrategy(target);
       if (strategy === "double") {
-        const cCode = compile3(c);
-        return `_fractal_mandelbrot_dp(vec4(${cCode}, vec2(0.0)), ${iterCode})`;
+        const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
+        return `_fractal_mandelbrot_dp(${dpCoord}, ${iterCode})`;
       }
       if (strategy === "perturbation") {
-        const cCode = compile3(c);
-        return `_fractal_mandelbrot_pt(${cCode}, ${iterCode})`;
+        const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
+        return `_fractal_mandelbrot_pt(${ptDelta}, ${iterCode})`;
       }
       return `_fractal_mandelbrot(${compile3(c)}, ${iterCode})`;
     },
@@ -61939,14 +61950,14 @@ Error in definition of "${name}"`,
       const iterCode = compileIntArg(maxIter, compile3, target);
       const strategy = selectFractalStrategy(target);
       if (strategy === "double") {
-        const zCode = compile3(z);
+        const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
         const cCode = compile3(c);
-        return `_fractal_julia_dp(vec4(${zCode}, vec2(0.0)), vec4(${cCode}, vec2(0.0)), ${iterCode})`;
+        return `_fractal_julia_dp(${dpCoord}, vec4(${cCode}, vec2(0.0)), ${iterCode})`;
       }
       if (strategy === "perturbation") {
-        const zCode = compile3(z);
+        const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
         const cCode = compile3(c);
-        return `_fractal_julia_pt(${zCode}, ${cCode}, ${iterCode})`;
+        return `_fractal_julia_pt(${ptDelta}, ${cCode}, ${iterCode})`;
       }
       return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${iterCode})`;
     },
@@ -62661,6 +62672,23 @@ fn ds_cmp(a: vec2f, b: vec2f) -> f32 {
 }
 `;
   var GPU_FRACTAL_DP_PREAMBLE_GLSL = `
+uniform float _dp_cx_hi;
+uniform float _dp_cx_lo;
+uniform float _dp_cy_hi;
+uniform float _dp_cy_lo;
+uniform float _dp_w;
+uniform float _dp_h;
+
+vec4 _dp_coord() {
+  // Per-pixel offset from center \u2014 small, so float-precise
+  float dx = (v_uv.x - 0.5) * _dp_w;
+  float dy = (v_uv.y - 0.5) * _dp_h;
+  // Combine center (hi+lo) + delta with emulated double precision
+  vec2 cre = ds_add(vec2(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
+  vec2 cim = ds_add(vec2(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
+  return vec4(cre.x, cim.x, cre.y, cim.y);
+}
+
 float _fractal_mandelbrot_dp(vec4 c, int maxIter) {
   // c = (re_hi, im_hi, re_lo, im_lo)
   vec2 cr = vec2(c.x, c.z);  // real part as ds
@@ -62701,6 +62729,21 @@ float _fractal_julia_dp(vec4 z_in, vec4 c, int maxIter) {
 }
 `;
   var GPU_FRACTAL_DP_PREAMBLE_WGSL = `
+@group(0) @binding(10) var<uniform> _dp_cx_hi: f32;
+@group(0) @binding(11) var<uniform> _dp_cx_lo: f32;
+@group(0) @binding(12) var<uniform> _dp_cy_hi: f32;
+@group(0) @binding(13) var<uniform> _dp_cy_lo: f32;
+@group(0) @binding(14) var<uniform> _dp_w: f32;
+@group(0) @binding(15) var<uniform> _dp_h: f32;
+
+fn _dp_coord(uv: vec2f) -> vec4f {
+  let dx = (uv.x - 0.5) * _dp_w;
+  let dy = (uv.y - 0.5) * _dp_h;
+  let cre = ds_add(vec2f(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
+  let cim = ds_add(vec2f(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
+  return vec4f(cre.x, cim.x, cre.y, cim.y);
+}
+
 fn _fractal_mandelbrot_dp(c: vec4f, maxIter: i32) -> f32 {
   let cr = vec2f(c.x, c.z);
   let ci = vec2f(c.y, c.w);
@@ -62786,6 +62829,16 @@ fn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {
 uniform sampler2D _refOrbit;
 uniform int _refOrbitLen;
 uniform int _refOrbitTexWidth;
+uniform float _pt_offset_x;
+uniform float _pt_offset_y;
+uniform float _pt_w;
+uniform float _pt_h;
+
+vec2 _pt_delta() {
+  float dx = _pt_offset_x + (v_uv.x - 0.5) * _pt_w;
+  float dy = _pt_offset_y + (v_uv.y - 0.5) * _pt_h;
+  return vec2(dx, dy);
+}
 
 vec2 _pt_fetch_orbit(int i) {
   int y = i / _refOrbitTexWidth;
@@ -62877,6 +62930,16 @@ float _fractal_julia_pt(vec2 z_delta, vec2 delta_c, int maxIter) {
 @group(0) @binding(1) var _refOrbit: texture_2d<f32>;
 var<uniform> _refOrbitLen: i32;
 var<uniform> _refOrbitTexWidth: i32;
+var<uniform> _pt_offset_x: f32;
+var<uniform> _pt_offset_y: f32;
+var<uniform> _pt_w: f32;
+var<uniform> _pt_h: f32;
+
+fn _pt_delta(uv: vec2f) -> vec2f {
+  let dx = _pt_offset_x + (uv.x - 0.5) * _pt_w;
+  let dy = _pt_offset_y + (uv.y - 0.5) * _pt_h;
+  return vec2f(dx, dy);
+}
 
 fn _pt_fetch_orbit(i: i32) -> vec2f {
   let y = i / _refOrbitTexWidth;
@@ -63474,8 +63537,32 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
             break;
         }
       }
+      if ((code.includes("_fractal_mandelbrot_dp") || code.includes("_fractal_julia_dp")) && options.hints?.viewport) {
+        const cx = hpToNumber(options.hints.viewport.center[0]);
+        const cy = hpToNumber(options.hints.viewport.center[1]);
+        const size = options.hints.viewport.radius * 2;
+        const cx_hi = Math.fround(cx);
+        const cy_hi = Math.fround(cy);
+        result.uniforms = {
+          ...result.uniforms,
+          _dp_cx_hi: cx_hi,
+          _dp_cx_lo: cx - cx_hi,
+          _dp_cy_hi: cy_hi,
+          _dp_cy_lo: cy - cy_hi,
+          _dp_w: size,
+          _dp_h: size
+        };
+      }
       if ((code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) && options.hints?.viewport) {
         const viewport = options.hints.viewport;
+        const size = viewport.radius * 2;
+        result.uniforms = {
+          ...result.uniforms,
+          _pt_offset_x: 0,
+          _pt_offset_y: 0,
+          _pt_w: size,
+          _pt_h: size
+        };
         const digits = Math.max(50, Math.ceil(-Math.log10(viewport.radius)) + 10);
         const maxIter = 1e3;
         const orbit = computeReferenceOrbit(
@@ -68482,7 +68569,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/core.ts
-  var version = "0.55.4";
+  var version = "0.55.5";
   return __toCommonJS(core_exports);
 })();
 /*! Bundled license information:

package/dist/interval.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.4 */
+/** Compute Engine 0.55.5 */
 
 // src/compute-engine/interval/util.ts
 function ok(value) {
@@ -13329,7 +13329,7 @@ var IntervalArithmetic = {
 };
 
 // src/interval.ts
-var version = "0.55.4";
+var version = "0.55.5";
 export {
   IntervalArithmetic,
   _mul,