@configura/babylon-view 1.4.0-alpha.4 → 1.4.0

package/dist/geometry/stretch/CfgStretchData.d.ts

@@ -1,115 +1,115 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { LengthValue, StretchMap } from "@configura/web-api";
-import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
-import { DetailLevel } from "@configura/web-core/dist/cm/geometry/DetailMask.js";
-import { Logger } from "@configura/web-utilities";
-/**
- * How far along from sp to ep is a point on a plane crossing the sp to ep line?
- * 1 means at ep, 0 means at sp.
- */
-export declare function calculateAlongness(p: Vector3, sp: Vector3, spToEpLength: number, normalizedNormal: Vector3): number;
-/**
- * Where does the point p end up given the CfgStretchDatas and the StretchMap.
- * This is the same equations that Babylon uses for stretching, only Babylon does it in the
- * shaders during rendering and is thus GPU accelerated.
- * This version is much slower, but that is okay as long as this function is sparingly used.
- */
-export declare const toStretchedPoint: (p: Vector3, stretchDatas: CfgStretchData[], stretchReferenceLengthsByMeasureParamCode: StretchMap) => Vector3;
-/**
- * The end of a section is the beginning of the next.
- * Start/end are redundant, but both are kept for ease of access.
- * The first section will have startAlongness 0. This does not mean that things can't be outside.
- * The start section should be thought of as endless in the sp-direction.
- * The last section will have endAlongness 0. This does not mean that things can't be outside.
- * The end section should be thought of as endless in the ep-direction.
- */
-export declare type StretchSection = {
-    last: boolean;
-    sizeChange: number;
-    move: boolean;
-    startAlongness: number;
-    endAlongness: number;
-    atTwiceTranslation: number;
-    atTwiceScale: number;
-};
-/**
- * Please note that stretch is not bound to be contained between sp and ep.
- *
- * The thinking in the equations in CfgStretchData is that we want to support MorphTargets in an as
- * efficient manner as possible. As MorphTargets work by morphing between pre-compiled meshes we
- * calculate what happens if you stretch to twice the referenceLength, to make MorphTargets for
- * twice the referenceLength, and then calculate how these MorphTargets should be applied to
- * achieve to requested referenceLength.
- *
- * This adaption to MorphTargets might make the code for stretching points for other purposes look
- * (be) a bit complicated. However, as a mesh often contains millions of vertices that needs to be
- * moved and calculating for bounding boxes, and anchor points and such moves very few vertices,
- * this is okay.
- *
- * Using "Twice" as the precomputed target is arbitrarily, we just chose it because it makes
- * equations simple.
- */
-export declare class CfgStretchData {
-    readonly detailLevel: DetailLevel;
-    readonly measureParam: string;
-    readonly originalReferenceLength: number | undefined;
-    readonly sp: Vector3;
-    readonly ep: Vector3;
-    readonly spToEpLength: number;
-    readonly originalSpToEpLength: number;
-    readonly normal: Vector3;
-    readonly normalNormalized: Vector3;
-    readonly sections: StretchSection[];
-    static make(logger: Logger, symNode: SymNode, detailLevel: DetailLevel): CfgStretchData;
-    private static processSections;
-    /**
-     * It is assumed that the symNode passed really is stretch (symNodeIsStretch has been run)
-     * so any data missing for stretch will be an Exception.
-     *
-     * @param detailLevel
-     * @param measureParam Name of the parameter controlling the stretch
-     * @param originalReferenceLength Server-side calculated original referenceLength. We do not
-     * actually use this for anything, but it can be handy for debug.
-     * @param sp Start Point, the start anchor of the stretch line.
-     * @param ep End Point, the end anchor of the stretch line.
-     * @param spToEpLength Distance from sp to ep.
-     * @param originalSpToEpLength spToEpLength before transforms.
-     * @param normal The normal is from sp to ep and is the normal of every plane that divides this
-     * stretch.
-     * @param normalNormalized Normalized version of normal
-     * @param sections The slices the model is sliced into
-     */
-    private constructor();
-    private _hash;
-    get hash(): number;
-    /** How far along between sp and ep is p? */
-    getAlongness: (p: Vector3) => number;
-    /**
-     * If the Matrix is identity the original CfgStretchData is returned.
-     * If not a new CfgStretchData will be created.
-     * sp, ep, spToEpLength, normal, normalNormalized, scale will be cloned and transformed
-     * The rest will still reference the original objects
-     */
-    applyMatrix(matrix: Matrix): CfgStretchData;
-    /**
-     * Calculates the translation of a point which moves it from its original position to where it
-     * would be if we stretched to twice the reference length. Please note: this gives the
-     * translation, not the new location. The new location will be p.add(stretchPointToTwice(p))
-     */
-    stretchPointToTwice(p: Vector3): Vector3;
-    /**
-     * Given a reference length calculates the influence that should be applied to a MorphTarget to
-     * achieve the requested length, given that these MorphTargets are constructed so that they
-     * will double the length when the influence 1 is applied.
-     *
-     * Please note that the referenceLength is the wanted length between sp and ep, that is, the
-     * stretch line. This line does not have to be span the entire model. Also, there can be
-     * multiple stretch lines that are not orthogonal to this, and the will also affect the actual
-     * size. Finally there can be transforms applied in the tree. So, the referenceLength will only
-     * be the actual length of the model in specific cases. However, we believe that models with
-     * stretch are often constructed in such a way that in real use cases the referenceLength is
-     * the actual real length.
-     */
-    calculateInfluenceGivenTwiceMorphTarget(referenceLength: LengthValue): number;
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { LengthValue, StretchMap } from "@configura/web-api";
+import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
+import { DetailLevel } from "@configura/web-core/dist/cm/geometry/DetailMask.js";
+import { Logger } from "@configura/web-utilities";
+/**
+ * How far along from sp to ep is a point on a plane crossing the sp to ep line?
+ * 1 means at ep, 0 means at sp.
+ */
+export declare function calculateAlongness(p: Vector3, sp: Vector3, spToEpLength: number, normalizedNormal: Vector3): number;
+/**
+ * Where does the point p end up given the CfgStretchDatas and the StretchMap.
+ * This is the same equations that Babylon uses for stretching, only Babylon does it in the
+ * shaders during rendering and is thus GPU accelerated.
+ * This version is much slower, but that is okay as long as this function is sparingly used.
+ */
+export declare const toStretchedPoint: (p: Vector3, stretchDatas: CfgStretchData[], stretchReferenceLengthsByMeasureParamCode: StretchMap) => Vector3;
+/**
+ * The end of a section is the beginning of the next.
+ * Start/end are redundant, but both are kept for ease of access.
+ * The first section will have startAlongness 0. This does not mean that things can't be outside.
+ * The start section should be thought of as endless in the sp-direction.
+ * The last section will have endAlongness 0. This does not mean that things can't be outside.
+ * The end section should be thought of as endless in the ep-direction.
+ */
+export declare type StretchSection = {
+    last: boolean;
+    sizeChange: number;
+    move: boolean;
+    startAlongness: number;
+    endAlongness: number;
+    atTwiceTranslation: number;
+    atTwiceScale: number;
+};
+/**
+ * Please note that stretch is not bound to be contained between sp and ep.
+ *
+ * The thinking in the equations in CfgStretchData is that we want to support MorphTargets in an as
+ * efficient manner as possible. As MorphTargets work by morphing between pre-compiled meshes we
+ * calculate what happens if you stretch to twice the referenceLength, to make MorphTargets for
+ * twice the referenceLength, and then calculate how these MorphTargets should be applied to
+ * achieve to requested referenceLength.
+ *
+ * This adaption to MorphTargets might make the code for stretching points for other purposes look
+ * (be) a bit complicated. However, as a mesh often contains millions of vertices that needs to be
+ * moved and calculating for bounding boxes, and anchor points and such moves very few vertices,
+ * this is okay.
+ *
+ * Using "Twice" as the precomputed target is arbitrarily, we just chose it because it makes
+ * equations simple.
+ */
+export declare class CfgStretchData {
+    readonly detailLevel: DetailLevel;
+    readonly measureParam: string;
+    readonly originalReferenceLength: number | undefined;
+    readonly sp: Vector3;
+    readonly ep: Vector3;
+    readonly spToEpLength: number;
+    readonly originalSpToEpLength: number;
+    readonly normal: Vector3;
+    readonly normalNormalized: Vector3;
+    readonly sections: StretchSection[];
+    static make(logger: Logger, symNode: SymNode, detailLevel: DetailLevel): CfgStretchData;
+    private static processSections;
+    /**
+     * It is assumed that the symNode passed really is stretch (symNodeIsStretch has been run)
+     * so any data missing for stretch will be an Exception.
+     *
+     * @param detailLevel
+     * @param measureParam Name of the parameter controlling the stretch
+     * @param originalReferenceLength Server-side calculated original referenceLength. We do not
+     * actually use this for anything, but it can be handy for debug.
+     * @param sp Start Point, the start anchor of the stretch line.
+     * @param ep End Point, the end anchor of the stretch line.
+     * @param spToEpLength Distance from sp to ep.
+     * @param originalSpToEpLength spToEpLength before transforms.
+     * @param normal The normal is from sp to ep and is the normal of every plane that divides this
+     * stretch.
+     * @param normalNormalized Normalized version of normal
+     * @param sections The slices the model is sliced into
+     */
+    private constructor();
+    private _hash;
+    get hash(): number;
+    /** How far along between sp and ep is p? */
+    getAlongness: (p: Vector3) => number;
+    /**
+     * If the Matrix is identity the original CfgStretchData is returned.
+     * If not a new CfgStretchData will be created.
+     * sp, ep, spToEpLength, normal, normalNormalized, scale will be cloned and transformed
+     * The rest will still reference the original objects
+     */
+    applyMatrix(matrix: Matrix): CfgStretchData;
+    /**
+     * Calculates the translation of a point which moves it from its original position to where it
+     * would be if we stretched to twice the reference length. Please note: this gives the
+     * translation, not the new location. The new location will be p.add(stretchPointToTwice(p))
+     */
+    stretchPointToTwice(p: Vector3): Vector3;
+    /**
+     * Given a reference length calculates the influence that should be applied to a MorphTarget to
+     * achieve the requested length, given that these MorphTargets are constructed so that they
+     * will double the length when the influence 1 is applied.
+     *
+     * Please note that the referenceLength is the wanted length between sp and ep, that is, the
+     * stretch line. This line does not have to be span the entire model. Also, there can be
+     * multiple stretch lines that are not orthogonal to this, and the will also affect the actual
+     * size. Finally there can be transforms applied in the tree. So, the referenceLength will only
+     * be the actual length of the model in specific cases. However, we believe that models with
+     * stretch are often constructed in such a way that in real use cases the referenceLength is
+     * the actual real length.
+     */
+    calculateInfluenceGivenTwiceMorphTarget(referenceLength: LengthValue): number;
+}
 //# sourceMappingURL=CfgStretchData.d.ts.map