@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/materials/LitMaterial.d.ts

@@ -0,0 +1,49 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../math/Color";
+import { Material } from "./Material";
+export declare class LitMaterial extends Material {
+    constructor();
+    clone(): Material;
+    set baseMap(texture: Texture);
+    get baseMap(): Texture;
+    set maskMap(texture: Texture);
+    get maskMap(): Texture;
+    set normalMap(texture: Texture);
+    get normalMap(): Texture;
+    set emissiveMap(texture: Texture);
+    get emissiveMap(): Texture;
+    set aoMap(texture: Texture);
+    get aoMap(): Texture;
+    set clearCoatRoughnessMap(texture: Texture);
+    get clearCoatRoughnessMap(): Texture;
+    set clearcoatColor(value: Color);
+    get clearcoatColor(): Color;
+    set clearcoatWeight(value: number);
+    get clearcoatWeight(): number;
+    set clearcoatFactor(value: number);
+    get clearcoatFactor(): number;
+    set clearcoatRoughnessFactor(value: number);
+    get clearcoatRoughnessFactor(): number;
+    set ior(value: number);
+    get ior(): number;
+    set alphaCutoff(value: number);
+    get alphaCutoff(): number;
+    /**
+     * set base color (tint color)
+     */
+    set baseColor(color: Color);
+    /**
+     * get base color (tint color)
+     */
+    get baseColor(): Color;
+    get roughness(): number;
+    set roughness(value: number);
+    get metallic(): number;
+    set metallic(value: number);
+    get emissiveColor(): Color;
+    set emissiveColor(value: Color);
+    get emissiveIntensity(): number;
+    set emissiveIntensity(value: number);
+    get ao(): number;
+    set ao(value: number);
+}

package/dist/types/materials/Material.d.ts

@@ -0,0 +1,67 @@
+import { StorageGPUBuffer } from "../gfx/graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { UniformGPUBuffer } from "../gfx/graphics/webGpu/core/buffer/UniformGPUBuffer";
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { RenderShaderPass } from "../gfx/graphics/webGpu/shader/RenderShaderPass";
+import { PassType } from "../gfx/renderJob/passRenderer/state/PassType";
+import { Shader } from "../gfx/graphics/webGpu/shader/Shader";
+import { Color } from "../math/Color";
+import { Vector2 } from "../math/Vector2";
+import { Vector3 } from "../math/Vector3";
+import { Vector4 } from "../math/Vector4";
+import { BlendMode } from "./BlendMode";
+export declare class Material {
+    instanceID: string;
+    name: string;
+    enable: boolean;
+    private _defaultSubShader;
+    protected _shader: Shader;
+    constructor();
+    set shader(shader: Shader);
+    get shader(): Shader;
+    get doubleSide(): boolean;
+    set doubleSide(value: boolean);
+    get castShadow(): boolean;
+    set castShadow(value: boolean);
+    get acceptShadow(): boolean;
+    set acceptShadow(value: boolean);
+    get castReflection(): boolean;
+    set castReflection(value: boolean);
+    get blendMode(): BlendMode;
+    set blendMode(value: BlendMode);
+    get depthCompare(): GPUCompareFunction;
+    set depthCompare(value: GPUCompareFunction);
+    get transparent(): boolean;
+    set transparent(value: boolean);
+    get cullMode(): GPUCullMode;
+    set cullMode(value: GPUCullMode);
+    get depthWriteEnabled(): boolean;
+    set depthWriteEnabled(value: boolean);
+    set useBillboard(value: boolean);
+    get topology(): GPUPrimitiveTopology;
+    set topology(value: GPUPrimitiveTopology);
+    set baseColor(color: Color);
+    get baseColor(): Color;
+    getPass(passType: PassType): RenderShaderPass[];
+    getAllPass(): RenderShaderPass[];
+    clone(): Material;
+    destroy(force: boolean): void;
+    setDefine(define: string, value: boolean): void;
+    setTexture(propertyName: string, texture: Texture): void;
+    setStorageBuffer(propertyName: string, buffer: StorageGPUBuffer): void;
+    setUniformBuffer(propertyName: string, buffer: UniformGPUBuffer): void;
+    setUniformFloat(propertyName: string, value: number): void;
+    setUniformVector2(propertyName: string, value: Vector2): void;
+    setUniformVector3(propertyName: string, value: Vector3): void;
+    setUniformVector4(propertyName: string, value: Vector4): void;
+    setUniformColor(propertyName: string, value: Color): void;
+    getUniformFloat(str: string): any;
+    getUniformV2(str: string): Vector2;
+    getUniformV3(str: string): Vector3;
+    getUniformV4(str: string): Vector4;
+    getUniformColor(str: string): Color;
+    getTexture(str: string): Texture;
+    getStorageBuffer(str: string): StorageGPUBuffer;
+    getStructStorageBuffer(str: string): import("..").GPUBufferBase;
+    getUniformBuffer(str: string): import("..").GPUBufferBase;
+    applyUniform(): void;
+}

package/dist/types/materials/MaterialRegister.d.ts

@@ -0,0 +1,9 @@
+import { Material } from "..";
+import { Ctor } from "../util/Global";
+/**
+ *
+ * @internal
+ * @group Material
+ */
+export type MaterialClassName = "MaterialBase" | "GBufferPass" | "GUIMaterial" | "ChromaKeyMaterial" | "LambertMaterial" | "SkyMaterial" | "UnLitMaterial" | "VideoMaterial" | "DepthMaterialPass" | "CastShadowMaterialPass" | "SkyGBufferPass" | "FlameSimulatorMaterial" | "FlowImgSimulatorMaterial" | "FluidSimulatorMaterial" | "FluidSimulatorMaterial2" | "HairSimulatorMaterial" | "LitMaterial" | "BoxMaterial" | "SkeletonMaterial" | "GlassMaterial" | "PavementMaterial" | "PointMaterial" | "none";
+export declare function registerMaterial(name: MaterialClassName, cls: Ctor<Material>): void;

package/dist/types/materials/ReflectionMaterial.d.ts

@@ -0,0 +1,13 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../math/Color";
+import { Material } from "./Material";
+export declare class ReflectionMaterial extends Material {
+    constructor();
+    set baseMap(texture: Texture);
+    get baseMap(): Texture;
+    set baseColor(color: Color);
+    set reflectionIndex(i: number);
+    get baseColor(): Color;
+    set envMap(texture: Texture);
+    set shadowMap(texture: Texture);
+}

package/dist/types/materials/SkyMaterial.d.ts

@@ -0,0 +1,13 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { Material } from "./Material";
+export declare class SkyMaterial extends Material {
+    constructor();
+    set baseMap(texture: Texture);
+    get baseMap(): Texture;
+    set envMap(texture: Texture);
+    set shadowMap(texture: Texture);
+    get exposure(): number;
+    set exposure(value: number);
+    get roughness(): number;
+    set roughness(value: number);
+}

package/dist/types/materials/UnLitMaterial.d.ts

@@ -0,0 +1,33 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../math/Color";
+import { Material } from "./Material";
+/**
+ * Unlit Mateiral
+ * 不接受光照的表面材质
+ * @group Material
+ */
+export declare class UnLitMaterial extends Material {
+    /**
+     * @constructor
+     */
+    constructor();
+    set baseMap(texture: Texture);
+    get baseMap(): Texture;
+    /**
+     * set base color (tint color)
+     */
+    set baseColor(color: Color);
+    /**
+     * get base color (tint color)
+     */
+    get baseColor(): Color;
+    /**
+     * set environment texture, usually referring to cubemap
+     */
+    set envMap(texture: Texture);
+    /**
+     * @internal
+     * set shadow map
+     */
+    set shadowMap(texture: Texture);
+}

package/dist/types/materials/UnLitTexArrayMaterial.d.ts

@@ -0,0 +1,20 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../math/Color";
+import { Material } from "./Material";
+export declare class UnLitTexArrayMaterial extends Material {
+    /**
+     * @constructor
+     */
+    constructor();
+    set baseMap(texture: Texture);
+    get baseMap(): Texture;
+    /**
+     * set base color (tint color)
+     */
+    set baseColor(color: Color);
+    /**
+     * get base color (tint color)
+     */
+    get baseColor(): Color;
+    set shadowMap(texture: Texture);
+}

package/dist/types/materials/multiPass/CastPointShadowMaterialPass.d.ts

@@ -0,0 +1,4 @@
+import { RenderShaderPass } from "../../gfx/graphics/webGpu/shader/RenderShaderPass";
+export declare class CastPointShadowMaterialPass extends RenderShaderPass {
+    constructor();
+}

package/dist/types/materials/multiPass/CastShadowMaterialPass.d.ts

@@ -0,0 +1,4 @@
+import { RenderShaderPass } from "../../gfx/graphics/webGpu/shader/RenderShaderPass";
+export declare class CastShadowMaterialPass extends RenderShaderPass {
+    constructor();
+}

package/dist/types/materials/multiPass/DepthMaterialPass.d.ts

@@ -0,0 +1,4 @@
+import { RenderShaderPass } from "../..";
+export declare class DepthMaterialPass extends RenderShaderPass {
+    constructor();
+}

package/dist/types/materials/multiPass/GBufferPass.d.ts

@@ -0,0 +1,5 @@
+import { RenderShaderPass } from "../../gfx/graphics/webGpu/shader/RenderShaderPass";
+export declare class GBufferPass extends RenderShaderPass {
+    transparency: number;
+    constructor();
+}

package/dist/types/materials/multiPass/SkyGBufferPass.d.ts

@@ -0,0 +1,4 @@
+import { RenderShaderPass } from "../../gfx/graphics/webGpu/shader/RenderShaderPass";
+export declare class SkyGBufferPass extends RenderShaderPass {
+    constructor();
+}

package/dist/types/math/AnimationCurve.d.ts

@@ -0,0 +1,42 @@
+import { FrameCache } from "./enum/FrameCache";
+import { WrapTimeMode } from "./enum/WrapTimeMode";
+import { Keyframe } from "./enum/Keyframe";
+export declare class AnimationCurve {
+    private _totalTime;
+    private _cache;
+    private _cacheOut;
+    private _InvalidateCache;
+    curve: Keyframe[];
+    serializedVersion: number;
+    preWarpMode: number;
+    postWarpMode: number;
+    rotationOrder: number;
+    get cacheOut(): {
+        lhsIndex: number;
+        rhsIndex: number;
+    };
+    constructor(frames?: Keyframe[], preWarpMode?: WrapTimeMode, postWarpMode?: WrapTimeMode);
+    get totalTime(): number;
+    get first(): Keyframe;
+    get last(): Keyframe;
+    addKeyFrame(keyFrame: Keyframe): void;
+    removeKeyFrame(keyFrame: Keyframe): void;
+    calculateCacheData(cache: FrameCache, lhsIndex: number, rhsIndex: number, timeOffset?: number): void;
+    getValue(time: number): number;
+    getCurveFramesExtent(time: number): {
+        lhsIndex: number;
+        rhsIndex: number;
+        time: number;
+    };
+    getKeyCount(): number;
+    getKey(index: number): Keyframe;
+    unSerialized(data: any): this;
+    unSerialized2(data: Object): this;
+    wrapTime(curveT: number): number;
+    private evaluateCache;
+    private findCurve;
+    private setupStepped;
+    private invalidateCache;
+    private calcTotalTime;
+    static scaleCurveValue(curve: AnimationCurve, scale: number): void;
+}

package/dist/types/math/AnimationCurveClip.d.ts

@@ -0,0 +1,15 @@
+import { AnimationCurveT, BytesArray } from "..";
+export declare class PropertyAnimationClip {
+    clipName: string;
+    loopTime: boolean;
+    startTime: number;
+    stopTime: number;
+    sampleRate: number;
+    useSkeletonPos: boolean;
+    useSkeletonScale: boolean;
+    positionCurves: Map<string, AnimationCurveT>;
+    rotationCurves: Map<string, AnimationCurveT>;
+    scaleCurves: Map<string, AnimationCurveT>;
+    floatCurves: Map<string, AnimationCurveT>;
+    formBytes(bytes: BytesArray): void;
+}

package/dist/types/math/AnimationCurveT.d.ts

@@ -0,0 +1,24 @@
+import { Keyframe } from "./enum/Keyframe";
+import { AnimationCurve, BytesArray, KeyframeT, Quaternion, Vector2, Vector3, Vector4 } from "..";
+export type CurveValueT = number | Vector2 | Vector3 | Vector4 | Quaternion;
+export declare class AnimationCurveT {
+    path: string;
+    attribute: string;
+    propertys: string[];
+    preInfinity: number;
+    postInfinity: number;
+    rotationOrder: number;
+    m_curves: AnimationCurve[];
+    private k;
+    private _cacheValue;
+    private _kValue;
+    constructor(k?: number);
+    private check;
+    get totalTime(): number;
+    addKeyFrame(keyFrame: KeyframeT): void;
+    removeKeyFrame(keyFrame: KeyframeT): void;
+    getValue(time: number): CurveValueT;
+    getKeyCount(): number;
+    getKey(index: number): Keyframe[];
+    formBytes(bytes: BytesArray): void;
+}

package/dist/types/math/BiMap.d.ts

@@ -0,0 +1,9 @@
+export declare class BiMap<K, V> extends Map<K, V> {
+    private readonly negtive;
+    constructor(iterable?: Iterable<readonly [K, V]> | null);
+    delete(key: K): boolean;
+    getKey(value: V): K;
+    deleteValue(value: V): boolean;
+    set(key: K, value: V): this;
+    clear(): void;
+}

package/dist/types/math/Color.d.ts

@@ -0,0 +1,249 @@
+export declare class Color {
+    /**
+     * red color
+     */
+    static COLOR_RED: Color;
+    /**
+     * green color
+     */
+    static COLOR_GREEN: Color;
+    /**
+     * blue color
+     */
+    static COLOR_BLUE: Color;
+    /**
+     * white color
+     */
+    static COLOR_WHITE: Color;
+    /**
+     * cache
+     * @internal
+     */
+    static COLOR_0: Color;
+    /**
+     * cache
+     * @internal
+     */
+    static COLOR_1: Color;
+    /**
+     * cache
+     * @internal
+     */
+    static COLOR_2: Color;
+    /**
+     * @internal
+     */
+    private static HEX_CHARACTERS;
+    /**
+     * @internal
+     */
+    private static MATCH_3OR4_HEX;
+    /**
+     * @internal
+     */
+    private static MATCH_6OR8_HEX;
+    /**
+     * @internal
+     */
+    private static NON_HEX_CHARS;
+    /**
+     * @internal
+     */
+    private static VALID_HEX_SIZE;
+    /**
+     * red channel
+     */
+    r: number;
+    /**
+     * green channel
+     */
+    g: number;
+    /**
+     * blue channel
+     */
+    b: number;
+    /**
+     * alpha channel
+     */
+    a: number;
+    constructor(r?: number, g?: number, b?: number, a?: number);
+    convertToHDRRGB(): Color;
+    unSerialized(data: any): this;
+    hexToRGB(value: number): Color;
+    hexToRGBA(value: number): Color;
+    static random(base?: number): Color;
+    static randomRGB(seedR?: number, seedG?: number, seedB?: number, baseR?: number, baseG?: number, baseB?: number): Color;
+    static randomGray(base?: number, random?: number): Color;
+    setTo(r: number, g: number, b: number, a: number): void;
+    setHex(hex: string): void;
+    getHex(): string;
+    /**
+     * get rgb to array
+     */
+    get rgb(): number[];
+    /**
+     * set rgb by array
+     */
+    set rgb(c: number[]);
+    /**
+     * get rgba to array
+     */
+    get rgba(): number[];
+    /**
+     * set rgb by array
+     */
+    set rgba(c: number[]);
+    clone(): Color;
+    copyFrom(src: Color): this;
+    copyFromArray(arr: number[], scalar?: number): this;
+    copyFromVector(value: {
+        x: number;
+        y: number;
+        z: number;
+        w?: number;
+    }): this;
+    static hexRGBColor(hexColor: number, dst?: Color): Color;
+    static lerp(v: number, c1: Color, c2: Color, target?: Color): Color;
+    static PRIMARY: number;
+    static PRIMARYDARK: number;
+    static ACCENT: number;
+    static WHITE: number;
+    static IVORY: number;
+    static LIGHTYELLOW: number;
+    static YELLOW: number;
+    static SNOW: number;
+    static FLORALWHITE: number;
+    static LEMONCHIFFON: number;
+    static CORNSILK: number;
+    static SEASHELL: number;
+    static LAVENDERBLUSH: number;
+    static PAPAYAWHIP: number;
+    static BLANCHEDALMOND: number;
+    static MISTYROSE: number;
+    static BISQUE: number;
+    static MOCCASIN: number;
+    static NAVAJOWHITE: number;
+    static PEACHPUFF: number;
+    static GOLD: number;
+    static PINK: number;
+    static LIGHTPINK: number;
+    static ORANGE: number;
+    static LIGHTSALMON: number;
+    static DARKORANGE: number;
+    static CORAL: number;
+    static HOTPINK: number;
+    static TOMATO: number;
+    static ORANGERED: number;
+    static DEEPPINK: number;
+    static FUCHSIA: number;
+    static MAGENTA: number;
+    static RED: number;
+    static OLDLACE: number;
+    static LIGHTGOLDENRODYELLOW: number;
+    static LINEN: number;
+    static ANTIQUEWHITE: number;
+    static SALMON: number;
+    static GHOSTWHITE: number;
+    static MINTCREAM: number;
+    static WHITESMOKE: number;
+    static BEIGE: number;
+    static WHEAT: number;
+    static SANDYBROWN: number;
+    static AZURE: number;
+    static HONEYDEW: number;
+    static ALICEBLUE: number;
+    static KHAKI: number;
+    static LIGHTCORAL: number;
+    static PALEGOLDENROD: number;
+    static VIOLET: number;
+    static DARKSALMON: number;
+    static LAVENDER: number;
+    static LIGHTCYAN: number;
+    static BURLYWOOD: number;
+    static PLUM: number;
+    static GAINSBORO: number;
+    static CRIMSON: number;
+    static PALEVIOLETRED: number;
+    static GOLDENROD: number;
+    static ORCHID: number;
+    static THISTLE: number;
+    static LIGHTGREY: number;
+    static TAN: number;
+    static CHOCOLATE: number;
+    static PERU: number;
+    static INDIANRED: number;
+    static MEDIUMVIOLETRED: number;
+    static SILVER: number;
+    static DARKKHAKI: number;
+    static ROSYBROWN: number;
+    static MEDIUMORCHID: number;
+    static DARKGOLDENROD: number;
+    static FIREBRICK: number;
+    static POWDERBLUE: number;
+    static LIGHTSTEELBLUE: number;
+    static PALETURQUOISE: number;
+    static GREENYELLOW: number;
+    static LIGHTBLUE: number;
+    static DARKGRAY: number;
+    static BROWN: number;
+    static SIENNA: number;
+    static DARKORCHID: number;
+    static PALEGREEN: number;
+    static DARKVIOLET: number;
+    static MEDIUMPURPLE: number;
+    static LIGHTGREEN: number;
+    static DARKSEAGREEN: number;
+    static SADDLEBROWN: number;
+    static DARKMAGENTA: number;
+    static DARKRED: number;
+    static BLUEVIOLET: number;
+    static LIGHTSKYBLUE: number;
+    static SKYBLUE: number;
+    static GRAY: number;
+    static OLIVE: number;
+    static PURPLE: number;
+    static MAROON: number;
+    static AQUAMARINE: number;
+    static CHARTREUSE: number;
+    static LAWNGREEN: number;
+    static MEDIUMSLATEBLUE: number;
+    static LIGHTSLATEGRAY: number;
+    static SLATEGRAY: number;
+    static OLIVEDRAB: number;
+    static SLATEBLUE: number;
+    static DIMGRAY: number;
+    static MEDIUMAQUAMARINE: number;
+    static CORNFLOWERBLUE: number;
+    static CADETBLUE: number;
+    static DARKOLIVEGREEN: number;
+    static INDIGO: number;
+    static MEDIUMTURQUOISE: number;
+    static DARKSLATEBLUE: number;
+    static STEELBLUE: number;
+    static ROYALBLUE: number;
+    static TURQUOISE: number;
+    static MEDIUMSEAGREEN: number;
+    static LIMEGREEN: number;
+    static DARKSLATEGRAY: number;
+    static SEAGREEN: number;
+    static FORESTGREEN: number;
+    static LIGHTSEAGREEN: number;
+    static DODGERBLUE: number;
+    static MIDNIGHTBLUE: number;
+    static AQUA: number;
+    static CYAN: number;
+    static SPRINGGREEN: number;
+    static LIME: number;
+    static MEDIUMSPRINGGREEN: number;
+    static DARKTURQUOISE: number;
+    static DEEPSKYBLUE: number;
+    static DARKCYAN: number;
+    static TEAL: number;
+    static GREEN: number;
+    static DARKGREEN: number;
+    static BLUE: number;
+    static MEDIUMBLUE: number;
+    static DARKBLUE: number;
+    static NAVY: number;
+    static BLACK: number;
+}

package/dist/types/math/ColorGradient.d.ts

@@ -0,0 +1,6 @@
+import { Color } from "./Color";
+export declare class ColorGradient {
+    private colorArray;
+    constructor(array: Color[]);
+    getColor(p: number): Color;
+}

package/dist/types/math/CubicBezierCurve.d.ts

@@ -0,0 +1,47 @@
+import { Vector3 } from "./Vector3";
+/**
+ * 三次贝塞尔曲线
+ * @group Math
+ */
+export declare class CubicBezierCurve {
+    private controlVertices;
+    /**
+     * @constructor
+     * @param cvs 更新控制点
+     */
+    constructor(cvs: Vector3[]);
+    /**
+     * 根据参数t计算曲线上点的位置
+     * @param t 参数值，范围[0-1]
+     * @returns 曲线上的点坐标(Vector3)
+     */
+    setControlVertices(cvs: Vector3[]): void;
+    /**
+     * 根据参数t计算曲线上点的位置
+     * @param t 参数值，范围[0-1]
+     * @returns 曲线上的点坐标(Vector3)
+     */
+    getPoint(t: number): Vector3;
+    /**
+     * 计算曲线上参数t处的切线方向
+     * @param t 参数值，范围[0-1]
+     * @returns 切线方向向量
+     */
+    getTangent(t: number): Vector3;
+    /**
+     * 获取曲线上最接近给定点的参数t值
+     * @param pos 给定的点位置
+     * @param paramThreshold 阈值
+     * @returns 参数t值，范围[0-1]
+     */
+    getClosestParam(pos: Vector3, paramThreshold?: number): number;
+    /**
+     * 递归计算给定范围内最接近点的参数t值
+     * @param pos 给定的点位置
+     * @param beginT 起始参数
+     * @param endT 结束参数
+     * @param thresholdT 阈值
+     * @returns 参数t值
+     */
+    getClosestParamRec(pos: Vector3, beginT: number, endT: number, thresholdT: number): number;
+}

package/dist/types/math/CubicBezierPath.d.ts

@@ -0,0 +1,37 @@
+import { Vector3 } from "./Vector3";
+/**
+ * 三次贝塞尔曲线类型
+ * @group Math
+ */
+export declare enum CubicBezierType {
+    Open = 0,
+    Closed = 1
+}
+/**
+ * @group Math
+ */
+export declare class CubicBezierPath {
+    private type;
+    private numCurveSegments;
+    private numControlVertices;
+    private controlVertices;
+    constructor(controlVertices: Vector3[], t?: CubicBezierType);
+    getPathType(): CubicBezierType;
+    isClosed(): boolean;
+    /**
+     * @returns
+     */
+    isValid(): boolean;
+    clear(): void;
+    computeApproxLength(): number;
+    computeApproxParamPerUnitLength(): number;
+    computeApproxNormParamPerUnitLength(): number;
+    interpolatePoints(knots: Vector3[], t: CubicBezierType): void;
+    setControlVertices(cvs: Vector3[], t: CubicBezierType): void;
+    getPoint(t: number): Vector3;
+    getPointNorm(t: number): Vector3;
+    getTangent(t: number): Vector3;
+    getTangentNorm(t: number): Vector3;
+    computeClosestParam(pos: Vector3, paramThreshold: number): number;
+    computeClosestNormParam(pos: Vector3, paramThreshold: number): number;
+}