Setup typescript + one example

Author: maximeq

dist/export.d.ts

@@ -1,14 +1,13 @@
-export const version: "1.0.0";
 import Types from "./blobtree/Types.js";
 import Element from "./blobtree/Element.js";
 import Node from "./blobtree/Node.js";
 import RootNode from "./blobtree/RootNode.js";
 import RicciNode from "./blobtree/RicciNode.js";
 import DifferenceNode from "./blobtree/DifferenceNode.js";
 import MinNode from "./blobtree/MinNode.js";
-import MaxNode from "./blobtree/MinNode.js";
 import TwistNode from "./blobtree/TwistNode";
 import ScaleNode from "./blobtree/ScaleNode";
+import MaxNode from "./blobtree/MinNode.js";
 import Primitive from "./blobtree/Primitive.js";
 import ScalisMath from "./blobtree/scalis/ScalisMath.js";
 import ScalisPrimitive from "./blobtree/scalis/ScalisPrimitive.js";
@@ -32,7 +31,8 @@ import AreaScalisTri from "./blobtree/areas/AreaScalisTri.js";
 import AreaSphere from "./blobtree/areas/AreaSphere.js";
 import AreaCapsule from "./blobtree/areas/AreaCapsule.js";
 import SlidingMarchingCubes from "./polygonizers/SlidingMarchingCubes.js";
-import SplitMaxPolygonizer from "./polygonizers/SplitMaxPolygonizer.js";
+import { SplitMaxPolygonizer } from "./polygonizers/SplitMaxPolygonizer";
 import SplitSMC from "./polygonizers/SplitSMC.js";
-export { Types, Element, Node, RootNode, RicciNode, DifferenceNode, MinNode, MaxNode, TwistNode, ScaleNode, Primitive, ScalisMath, ScalisPrimitive, ScalisPoint, ScalisSegment, ScalisTriangle, ScalisVertex, DistanceFunctor, Poly6DistanceFunctor, SDFRootNode, SDFPrimitive, SDFPoint, SDFSegment, SDFSphere, SDFCapsule, Material, Accuracies, Area, AreaScalisSeg, AreaScalisTri, AreaSphere, AreaCapsule, SlidingMarchingCubes, SplitMaxPolygonizer, SplitSMC };
+declare const version = "1.0.0";
+export { version, Types, Element, Node, RootNode, RicciNode, DifferenceNode, MinNode, MaxNode, TwistNode, ScaleNode, Primitive, ScalisMath, ScalisPrimitive, ScalisPoint, ScalisSegment, ScalisTriangle, ScalisVertex, DistanceFunctor, Poly6DistanceFunctor, SDFRootNode, SDFPrimitive, SDFPoint, SDFSegment, SDFSphere, SDFCapsule, Material, Accuracies, Area, AreaScalisSeg, AreaScalisTri, AreaSphere, AreaCapsule, SlidingMarchingCubes, SplitMaxPolygonizer, SplitSMC, };
 //# sourceMappingURL=export.d.ts.map

dist/export.d.ts.map

@@ -1,70 +1,56 @@
-export = SplitMaxPolygonizer;
-/**
- * @typedef {import('./SlidingMarchingCubes').SMCParams} SMCParams
- */
+import RootNode from "../blobtree/RootNode";
+declare type ConvergenceParams = {
+    ratio?: number;
+    step?: number;
+};
+declare type SMCParams = {
+    zResolution?: "adaptive" | "uniform";
+    detailRatio?: number;
+    progress?: (percent: number) => void;
+    convergence?: ConvergenceParams;
+    dichotomy?: number;
+};
 /**
- * @typedef {SMCParams & {class: any}} SubPolygonizerParams
+ * Parameters for the subpolygonizer to use.
+ * Contain a className which will be mapped to a constructor, and parameters related to that polygonizer
  */
+declare type SubPolygonizerParams = {
+    className: "SlidingMarchingCubes";
+    smcParams?: SMCParams;
+};
 /**
  * @typedef {Object} SplitMaxPolygonizerParams
- * @property {SubPolygonizerParams=} subPolygonizer Parameters for the subpolygonizer to use.
- *                                           Must contain all parameters for the given subPolygonizer (like detailRatio, etc...)
- *                                           The class of the subpolygonizer (default to SlidingMarchingCubes) is in additional parameter class
- * @property {Boolean=} smpParams.uniformRes If true, uniform resolution will be used on all primitives, according to the minimum accuracy in the blobtree.
- * @property {Function=} smpParams.progress Progress callback, taking a percentage as parameter.
- * @property {Number=} smpParams.ricciThreshold The RicciNode coefficient above which it will be considered like a MaxNode.
+ * @property {SubPolygonizerParams=} subPolygonizer P
+ * @property {Boolean=} smpParams.uniformRes
+ * @property {Function=} smpParams.progress
+ * @property {Number=} smpParams.ricciThreshold
  */
+export declare type SplitMaxPolygonizerParams = {
+    subPolygonizer?: SubPolygonizerParams;
+    uniformRes?: boolean;
+    progress?: (percent: number) => void;
+    ricciThreshold?: number;
+};
 /**
  *  This class will polygonize nodes independantly when they blend with a MaxNode or a RicciNode
  *  (for RicciNode, only if the coefficient of at least "ricciThreshold", threshold being a parameter).
  *  It will create a mesh made of several shells but intersections will be better looking than with some
  *  global polygonizers like MarchingCubes.
  */
-declare class SplitMaxPolygonizer {
-    /**
-     *  @param {SplitMaxPolygonizerParams=} smpParams Parameters and option for this polygonizer.
-     */
-    constructor(blobtree: any, smpParams?: SplitMaxPolygonizerParams | undefined);
-    blobtree: any;
-    uniformRes: boolean;
-    min_acc: any;
-    minAccs: any[];
-    /** @type {SubPolygonizerParams} */
-    subPolygonizer: SubPolygonizerParams;
-    ricciThreshold: number;
-    progress: Function;
-    subtrees: any[];
-    progCoeff: any[];
-    totalCoeff: number;
-    constructor: typeof import("./SplitMaxPolygonizer");
-    setBlobtree(blobtree: any): void;
-    compute(): THREE.BufferGeometry;
-}
-declare namespace SplitMaxPolygonizer {
-    export { SMCParams, SubPolygonizerParams, SplitMaxPolygonizerParams };
+export declare class SplitMaxPolygonizer {
+    private blobtree;
+    private uniformRes;
+    private min_acc;
+    private minAccs;
+    private subPolygonizer;
+    readonly ricciThreshold: number;
+    private progress;
+    private subtrees;
+    private progCoeff;
+    private totalCoeff;
+    constructor(blobtree: RootNode, smpParams: SplitMaxPolygonizerParams);
+    setBlobtree(blobtree: RootNode): void;
+    compute(): import("three").BufferGeometry;
 }
-type SubPolygonizerParams = SMCParams & {
-    class: any;
-};
-type SplitMaxPolygonizerParams = {
-    /**
-     * Parameters for the subpolygonizer to use.
-     * Must contain all parameters for the given subPolygonizer (like detailRatio, etc...)
-     * The class of the subpolygonizer (default to SlidingMarchingCubes) is in additional parameter class
-     */
-    subPolygonizer?: SubPolygonizerParams | undefined;
-    /**
-     * If true, uniform resolution will be used on all primitives, according to the minimum accuracy in the blobtree.
-     */
-    uniformRes?: boolean | undefined;
-    /**
-     * Progress callback, taking a percentage as parameter.
-     */
-    progress?: Function | undefined;
-    /**
-     * The RicciNode coefficient above which it will be considered like a MaxNode.
-     */
-    ricciThreshold?: number | undefined;
-};
-type SMCParams = import('./SlidingMarchingCubes').SMCParams;
+export {};
 //# sourceMappingURL=SplitMaxPolygonizer.d.ts.map