wasm readPoly and some debugging

src/geo/polygons.js

@@ -312,17 +312,22 @@
         // expensive but worth it?
         clip.StrictlySimple = true;
 
-        if (outA) {
+        const JS = true;
-            clip.AddPaths(sp1, ptyp.ptSubject, true);
-            clip.AddPaths(sp2, ptyp.ptClip, true);
 
-            if (clip.Execute(ctyp.ctDifference, ctre, cfil.pftEvenOdd, cfil.pftEvenOdd)) {
+        if (outA) {
-                cleanClipperTree(ctre);
+            if (JS) {
-                filter(fromClipperTree(ctre, z, null, null, min), outA);
+                clip.AddPaths(sp1, ptyp.ptSubject, true);
+                clip.AddPaths(sp2, ptyp.ptClip, true);
+
+                if (clip.Execute(ctyp.ctDifference, ctre, cfil.pftEvenOdd, cfil.pftEvenOdd)) {
+                    cleanClipperTree(ctre);
+                    filter(fromClipperTree(ctre, z, null, null, min), outA);
+                }
+            } else {
+                let woutA = filter(geo.poly.diff(setA, setB, z));
+                outA.appendAll(woutA);
+                console.log({outA, woutA});
             }
-            // let woutA = filter(geo.poly.diff(setA, setB, z));
-            // outA.appendAll(woutA);
-            // console.log({outA, woutA});
         }
 
         if (outB) {
@@ -331,16 +336,19 @@
                 clip.Clear();
             }
 
-            clip.AddPaths(sp2, ptyp.ptSubject, true);
+            if (JS) {
-            clip.AddPaths(sp1, ptyp.ptClip, true);
+                clip.AddPaths(sp2, ptyp.ptSubject, true);
+                clip.AddPaths(sp1, ptyp.ptClip, true);
 
-            if (clip.Execute(ctyp.ctDifference, ctre, cfil.pftEvenOdd, cfil.pftEvenOdd)) {
+                if (clip.Execute(ctyp.ctDifference, ctre, cfil.pftEvenOdd, cfil.pftEvenOdd)) {
-                cleanClipperTree(ctre);
+                    cleanClipperTree(ctre);
-                filter(fromClipperTree(ctre, z, null, null, min), outB);
+                    filter(fromClipperTree(ctre, z, null, null, min), outB);
+                }
+            } else {
+                let woutB = filter(geo.poly.diff(setB, setA, z));
+                outB.appendAll(woutB);
+                console.log({outB, woutB});
             }
-            // let woutB = filter(geo.poly.diff(setB, setA, z));
-            // outB.appendAll(woutB);
-            // console.log({outB, woutB});
         }
 
         return out;

src/geo/wasm.js

@@ -9,6 +9,7 @@ if (!self.window) (function() {
 
     const factor = self.base.config.clipper;
     const geo = self.geo;
+    const debug = false;
 
     geo.poly = {
         diff: polyDiff,
@@ -70,6 +71,9 @@ if (!self.window) (function() {
                 break;
             }
         }
+        // if (debug) {
+        //     console.log({diff_resat: resat, memat});
+        // }
         wasm.free(memat);
         return polyNest(out);
     }
@@ -114,6 +118,9 @@ if (!self.window) (function() {
                 break;
             }
         }
+        // if (debug) {
+        //     console.log({diff_resat: resat, memat, delta: resat-memat});
+        // }
         wasm.free(memat);
         return polyNest(out);
     }
@@ -146,13 +153,24 @@ if (!self.window) (function() {
         return tops;
     }
 
+    function runTests() {
+        let newPolygon = self.base.newPolygon;
+        let p1 = newPolygon().add(0,0).add(4,0).add(4,4).add(0,4);
+        let p2 = p1.clone().setZ(0).move({x:2, y:2});
+        let d1 = geo.poly.diff([p1], [p2], 0);
+        let d2 = geo.poly.diff([p2], [p1], 0);
+        console.log('diff',{p1:p1.points, p2:p2.points, d1:d1[0].points, d2:d2[0].points});
+        let o1 = geo.poly.offset([p1], 1, 0);
+        console.log('offs',{o1:o1[0].points});
+    }
+
     fetch('/wasm/kiri-geo.wasm')
         .then(response => response.arrayBuffer())
         .then(bytes => WebAssembly.instantiate(bytes, {
             env: {
                 polygon: (a,b) => { console.log('polygon',a,b) },
                 point: (a,b) => { console.log('point',a,b) },
-                abs:  (a) => { console.log('abs',a); return Math.abs(a) }
+                abc:  (a,b,c) => { console.log('abc',a,b,c) }
             },
             wasi_snapshot_preview1: {
                 args_get: (count,bufsize) => { return 0 },
@@ -170,15 +188,16 @@ if (!self.window) (function() {
                 heap,
                 exports,
                 memory: exports.memory,
+                memmax: exports.memory.buffer.byteLength,
                 malloc: exports.mem_get,
-                start: exports._start,
                 free: exports.mem_clr,
                 diff: exports.poly_diff,
                 union: exports.poly_union,
                 offset: exports.poly_offset
             };
-
+            if (debug) {
-            // wasm.start();
+                runTests();
+            }
         });
 
 })();

wasm/kiri-geo.cpp

@@ -8,11 +8,15 @@ typedef unsigned short Uint16;
 typedef unsigned int Uint32;
 typedef int int32;
 
+using namespace ClipperLib;
+
 Uint8 *mem = 0;
+const Uint8 debug = 0;
 
 extern "C" {
     extern void polygon(Uint32 points, Uint32 inners);
     extern void point(Uint32 x, Uint32 y);
+    extern void abc(Uint32 a, Uint32 b, Uint32 c);
 }
 
 struct length16 {
@@ -34,30 +38,53 @@ void mem_clr(Uint32 loc) {
     free((void *)loc);
 }
 
+Uint32 readPolys(Paths paths, Uint32 pos, Uint32 count) {
+    Uint32 poly = 0;
+    if (debug) abc(poly, count, pos);
+    while (count > 0) {
+        struct length16 *ls = (struct length16 *)(mem + pos);
+        Uint16 points = ls->length;
+        if (debug) polygon(points, 0);
+        pos += 2;
+        while (points-- > 0) {
+            struct point32 *ip = (struct point32 *)(mem + pos);
+            pos += 8;
+            paths[poly] << IntPoint(ip->x, ip->y);
+            if (debug) point(ip->x, ip->y);
+        }
+        poly++;
+        count--;
+    }
+    if (debug) abc(poly, count, pos);
+    return pos;
+}
+
 __attribute__ ((export_name("poly_offset")))
 Uint32 poly_offset(Uint32 memat, Uint32 polys, float offset) {
 
-    using namespace ClipperLib;
-
     Paths ins(polys);
     Paths outs;
     Uint32 pos = memat;
     Uint16 poly = 0;
 
+    // pos = readPolys(ins, pos, polys);
+
     while (poly < polys) {
         struct length16 *ls = (struct length16 *)(mem + pos);
         Uint16 points = ls->length;
-        // polygon(points, 0);
+        if (debug) polygon(points, 0);
         pos += 2;
         while (points-- > 0) {
             struct point32 *ip = (struct point32 *)(mem + pos);
             pos += 8;
             ins[poly] << IntPoint(ip->x, ip->y);
-            // point(ip->x, ip->y);
+            if (debug) point(ip->x, ip->y);
         }
         poly++;
     }
 
+    if (debug) abc(memat, pos, memat - pos);
+
     // clean and simplify polygons
     // Paths cleans, simples;
     // CleanPolygons(ins, cleans, 250);
@@ -71,12 +98,12 @@ Uint32 poly_offset(Uint32 memat, Uint32 polys, float offset) {
     Uint32 resat = pos;
 
     for (Path po : outs) {
-        // polygon(po.size(), 1);
+        if (debug) polygon(po.size(), 1);
         struct length16 *ls = (struct length16 *)(mem + pos);
         ls->length = po.size();
         pos += 2;
         for (IntPoint pt : po) {
-            // point(pt.X, pt.Y);
+            if (debug) point(pt.X, pt.Y);
             struct point32 *ip = (struct point32 *)(mem + pos);
             ip->x = (int)pt.X;
             ip->y = (int)pt.Y;
@@ -96,8 +123,6 @@ Uint32 poly_offset(Uint32 memat, Uint32 polys, float offset) {
 __attribute__ ((export_name("poly_union")))
 Uint32 poly_union(Uint32 memat, Uint32 polys, float offset) {
 
-    using namespace ClipperLib;
-
     Paths ins(polys);
     Paths outs;
     Uint32 pos = memat;
@@ -147,8 +172,6 @@ Uint32 poly_union(Uint32 memat, Uint32 polys, float offset) {
 __attribute__ ((export_name("poly_diff")))
 Uint32 poly_diff(Uint32 memat, Uint32 polysA, Uint32 polysB, float offset) {
 
-    using namespace ClipperLib;
-
     Paths inA(polysA);
     Paths inB(polysB);
     Paths outs;