CJS => ESM

Author: ersbeth

dist/three-js-blobtree.module.js

@@ -1,4 +1,4 @@
-export = DifferenceNode;
+import { Node } from "./Node";
 /**
  * @typedef {import('./Element.js')} Element
  * @typedef {import('./Element.js').Json} Json
@@ -14,62 +14,40 @@ export = DifferenceNode;
  *  @constructor
  *  @extends Node
  */
-declare class DifferenceNode extends Node {
+export declare class DifferenceNode extends Node {
+    static type: string;
     /**
      * @param {DifferenceNodeJSON} json
      * @returns {DifferenceNode}
      */
-    static fromJSON(json: DifferenceNodeJSON): DifferenceNode;
+    static fromJSON(json: any): DifferenceNode;
     /**
      *
      *  @param {!Node} node0 The first node
      *  @param {!Node} node1 The second node, its value will be substracted to the node 0 value.
      *  @param {number} alpha Power of the second field : the greater alpha the sharper the difference. Default is 1, must be > 1.
      */
-    constructor(node0: Node, node1: Node, alpha: number);
-    /** @type {number} */
-    alpha: number;
-    /**
-     * For now, this field value is clamped to 0
-     * @type {number}
-     */
-    clamped: number;
-    /** @type {{v:number, g:THREE.Vector3, m:Material}} */
-    tmp_res0: {
-        v: number;
-        g: THREE.Vector3;
-        m: Material;
-    };
-    /** @type {{v:number, g:THREE.Vector3, m:Material}} */
-    tmp_res1: {
-        v: number;
-        g: THREE.Vector3;
-        m: Material;
-    };
-    /** @type {THREE.Vector3} */
-    g0: THREE.Vector3;
-    /** @type {Material} */
-    m0: Material;
-    /** @type {THREE.Vector3} */
-    g1: THREE.Vector3;
-    /** @type {Material} */
-    m1: Material;
-    /** @type {Float32Array} */
-    tmp_v_arr: Float32Array;
-    /** @type {Array<Material|null>} */
-    tmp_m_arr: Array<Material | null>;
+    constructor(node0: any, node1: any, alpha: any);
     /**
      * @returns {number}
      */
-    getAlpha(): number;
+    getAlpha(): any;
     /**
      * @param {number} alpha
      */
-    setAlpha(alpha: number): void;
+    setAlpha(alpha: any): void;
     /**
      * @returns {DifferenceNodeJSON}
      */
-    toJSON(): DifferenceNodeJSON;
+    toJSON(): {
+        alpha: any;
+        children: never[];
+        type: string;
+    };
+    /**
+     * @link Node.prepareForEval for a complete description
+     **/
+    prepareForEval(): void;
     /**
      *  Compute the value and/or gradient and/or material
      *  of the element at position p in space. return computations in res (see below)
@@ -83,24 +61,16 @@ declare class DifferenceNode extends Node {
      *  @param {number=} res.step The next step we can safely walk without missing the iso (0). Mostly used for convergence function or ray marching.
      *  @param {number=} res.stepOrtho
      */
-    value(p: THREE.Vector3, res: {
-        v: number;
-        m: Material;
-        g: THREE.Vector3;
-        step?: number | undefined;
-        stepOrtho?: number | undefined;
-    }): void;
-}
-declare namespace DifferenceNode {
-    export { Element, Json, NodeJSON, DifferenceNodeJSON };
+    value(p: any, res: any): void;
+    /**
+     *  @link Element.trim for a complete description.
+     *
+     *  Trim must be redefined for DifferenceNode since in this node we cannot trim one of the 2 nodes without trimming the other.
+     *
+     *  @param {THREE.Box3} aabb
+     *  @param {Array.<Element>} trimmed
+     *  @param {Array.<Node>} parents
+     */
+    trim(aabb: any, trimmed: any, parents: any): void;
 }
-import Node = require("./Node.js");
-import THREE = require("three");
-import Material = require("./Material.js");
-type Element = import('./Element.js');
-type Json = import('./Element.js').Json;
-type NodeJSON = import('./Node.js').NodeJSON;
-type DifferenceNodeJSON = {
-    alpha: number;
-} & NodeJSON;
 //# sourceMappingURL=DifferenceNode.d.ts.map

dist/three-js-blobtree.module.js.map

@@ -1,35 +1,32 @@
-export = Element;
 /**
  *  A superclass for Node and Primitive in the blobtree.
  *  @class
  *  @constructor
  */
-declare class Element {
+export declare class Element {
     static type: string;
     /**
      * @param {ElementJSON} _json
      */
-    static fromJSON(_json: ElementJSON): void;
-    id: number;
-    aabb: THREE.Box3;
-    valid_aabb: boolean;
-    /** @type {Node} */
-    parentNode: Node;
+    static fromJSON(_json: any): void;
+    constructor();
     /**
      *  Return a Javscript Object respecting JSON convention.
      *  All classes must defined it.
      *  @return {ElementJSON}
      */
-    toJSON(): ElementJSON;
+    toJSON(): {
+        type: string;
+    };
     /**
      *  Clone the object.
      * @return {Element}
      */
-    clone(): Element;
+    clone(): any;
     /**
      *  @return {Node} The parent node of this primitive.
      */
-    getParentNode(): Node;
+    getParentNode(): any;
     /**
      *  @return {string} Type of the element
      */
@@ -39,7 +36,7 @@ declare class Element {
      *  especially on calls to value.
      *  @protected
      */
-    protected computeHelpVariables(): void;
+    computeHelpVariables(): void;
     /**
      *  @abstract
      *  Compute the Axis Aligned Bounding Box (AABB) for the current primitive.
@@ -52,12 +49,12 @@ declare class Element {
      *  isValidAABB before to ensure the current AABB does correspond to the primitive
      *  settings.
      */
-    getAABB(): THREE.Box3;
+    getAABB(): any;
     /**
      *  @return {boolean} True if the current aabb is valid, ie it does
      *  correspond to the internal primitive parameters.
      */
-    isValidAABB(): boolean;
+    isValidAABB(): any;
     /**
      *  Invalid the bounding boxes recursively up to the root
      */
@@ -82,13 +79,13 @@ declare class Element {
      *  @param {THREE.Vector3} _p Point where we want to evaluate the primitive field
      *  @param {ValueResultType} _res
      */
-    value(_p: THREE.Vector3, _res: ValueResultType): void;
+    value(_p: any, _res: any): void;
     /**
      * @param {THREE.Vector3} p The point where we want the numerical gradient
      * @param {THREE.Vector3} res The resulting gradient
      * @param {number} epsilon The step value for the numerical evaluation
      */
-    numericalGradient: (p: THREE.Vector3, res: THREE.Vector3, epsilon: number) => void;
+    numericalGradient: (p: any, res: any, epsilon: any) => void;
     /**
      *  @abstract
      *  Get the Area object.
@@ -97,24 +94,20 @@ declare class Element {
      *  capture the feature nicely, etc etc...).
      *  @returns {Array.<{aabb: THREE.Box3, bv:Area, obj:Primitive}>} The Areas object corresponding to the node/primitive, in an array
      */
-    getAreas(): Array<{
-        aabb: THREE.Box3;
-        bv: Area;
-        obj: Primitive;
-    }>;
+    getAreas(): never[];
     /**
      *  @abstract
      *  This function is called when a point is outside of the potential influence of a primitive/node.
      *  @param {THREE.Vector3} _p
      *  @return {number} The next step length to do with respect to this primitive/node
      */
-    distanceTo(_p: THREE.Vector3): number;
+    distanceTo(_p: any): void;
     /**
      *  @abstract
      *  This function is called when a point is within the potential influence of a primitive/node.
      *  @return {number} The next step length to do with respect to this primitive/node.
      */
-    heuristicStepWithin(): number;
+    heuristicStepWithin(): void;
     /**
      *  Trim the tree to keep only nodes influencing a given bounding box.
      *  The tree must be prepared for eval for this process to be working.
@@ -125,51 +118,13 @@ declare class Element {
      *  @param {Array.<Element>} _trimmed Array of trimmed Elements
      *  @param {Array.<Node>} _parents Array of fathers from which each trimmed element has been removed.
      */
-    trim(_aabb: THREE.Box3, _trimmed: Array<Element>, _parents: Array<Node>): void;
+    trim(_aabb: any, _trimmed: any, _parents: any): void;
     /**
      *  count the number of elements of class cls in this node and subnodes
      *  @param {Function} _cls the class of the elements we want to count
      *  @return {number} The number of element of class cls
      */
-    count(_cls: Function): number;
+    count(_cls: any): number;
     destroy(): void;
 }
-declare namespace Element {
-    export { Material, Node, Primitive, Json, Area, ElementJSON, ValueResultType };
-}
-import THREE = require("three");
-type Node = import('./Node.js');
-type Material = import('./Material.js');
-type Primitive = import('./Primitive');
-type Json = any;
-type Area = import('./areas/Area');
-type ElementJSON = {
-    type: string;
-};
-/**
- * Computed values will be stored here. Each values should exist and
- *                    be allocated already.
- */
-type ValueResultType = {
-    /**
-     * Value, must be defined
-     */
-    v: number;
-    /**
-     * Material, must be allocated and defined if wanted
-     */
-    m?: Material | undefined;
-    /**
-     * Gradient, must be allocated and defined if wanted
-     */
-    g?: THREE.Vector3 | undefined;
-    /**
-     * ??? Not sure, probably a "safe" step for raymarching
-     */
-    step?: number | undefined;
-    /**
-     * ??? Same as step but in orthogonal direction ?
-     */
-    stepOrtho?: number | undefined;
-};
 //# sourceMappingURL=Element.d.ts.map