@rings-webgpu/core 1.0.6 → 1.0.7

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

@@ -0,0 +1,38 @@
+export declare class Vector2 {
+    static HELP_0: Vector2;
+    static HELP_1: Vector2;
+    static HELP_2: Vector2;
+    static readonly ZERO: Vector2;
+    static readonly SAFE_MAX: Vector2;
+    static readonly SAFE_MIN: Vector2;
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    static getAngle(a: Vector2, b: Vector2): number;
+    static slerp(from: Vector2, to: Vector2, t: number): Vector2;
+    static lerp(from: Vector2, to: Vector2, t: number): Vector2;
+    set(x?: number, y?: number): this;
+    distance(a: Vector2): number;
+    add(a: Vector2, target?: Vector2): Vector2;
+    sub(a: Vector2, target?: Vector2): Vector2;
+    scale(v: number): this;
+    multiply(a: number, target?: Vector2): Vector2;
+    multiplyScaler(a: number): this;
+    divide(v: number, target?: Vector2): Vector2;
+    neg(target?: Vector2): Vector2;
+    abs(): number;
+    length(): number;
+    getAngle(target: Vector2): number;
+    unt(target?: Vector2): Vector2;
+    angleTo(v: Vector2): number;
+    equals(a: Vector2): boolean;
+    pal(a: Vector2): number;
+    clone(): Vector2;
+    copyFrom(v: Vector2): Vector2;
+    addScaledVector(v: Vector2, size: number): Vector2;
+    dot(value: Vector2): number;
+    normalize(): this;
+    addInPlace(otherVector: Vector2): this;
+    addScalar(s: number): this;
+    clampScalar(minVal: number, maxVal: number): this;
+}

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

@@ -0,0 +1,107 @@
+export declare class Vector3 {
+    static readonly MAX: Vector3;
+    static readonly MIN: Vector3;
+    static readonly SAFE_MAX: Vector3;
+    static readonly SAFE_MIN: Vector3;
+    static readonly X_AXIS: Vector3;
+    static readonly neg_X_AXIS: Vector3;
+    static readonly Y_AXIS: Vector3;
+    static readonly Z_AXIS: Vector3;
+    static HELP_0: Vector3;
+    static HELP_1: Vector3;
+    static HELP_2: Vector3;
+    static readonly EPSILON: number;
+    static HELP_3: Vector3;
+    static HELP_4: Vector3;
+    static HELP_5: Vector3;
+    static HELP_6: Vector3;
+    static get ZERO(): Vector3;
+    static get ONE(): Vector3;
+    static get LEFT(): Vector3;
+    static get RIGHT(): Vector3;
+    static get UP(): Vector3;
+    static get DOWN(): Vector3;
+    static get BACK(): Vector3;
+    static get FORWARD(): Vector3;
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    index: number;
+    private static _index;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    set a(value: number);
+    set r(value: number);
+    set g(value: number);
+    set b(value: number);
+    get a(): number;
+    get r(): number;
+    get g(): number;
+    get b(): number;
+    get length(): number;
+    get lengthSquared(): number;
+    get position(): this;
+    static getTowPointbyDir(dir: Vector3, tp1: Vector3, tp2: Vector3, width: number, aix: Vector3): void;
+    static pointToLine(point1: Vector3, point2: Vector3, position: Vector3): number;
+    static dot(a: Vector3, b: Vector3): number;
+    static getPoints(total: number, randSeed: number): any[];
+    static getPointNumbers(total: number, randSeed: number): any[];
+    static getAngle(from: Vector3, to: Vector3): number;
+    static sqrMagnitude(arg0: Vector3): number;
+    static getZYAngle(zd: Vector3, yd: Vector3): number;
+    static sub(a: Vector3, b: Vector3, target?: Vector3): Vector3;
+    static add(a: Vector3, b: Vector3, target?: Vector3): Vector3;
+    static smoothDamp(current: Vector3, target: Vector3, currentVelocity: Vector3, smoothTime: number, maxSpeed: number, deltaTime: number): any;
+    static distance(pt1: Vector3, pt2: Vector3): number;
+    static squareDistance(pt1: Vector3, pt2: Vector3): number;
+    static distanceXZ(pt1: Vector3, pt2: Vector3): number;
+    set(x: number, y: number, z: number, w?: number): this;
+    add(a: Vector3, target?: Vector3): Vector3;
+    subVectors(a: Vector3, b: Vector3): this;
+    addScalar(scalar: number): Vector3;
+    subScalar(scalar: number): Vector3;
+    min(v: Vector3, target?: Vector3): Vector3;
+    max(v: Vector3, target?: Vector3): Vector3;
+    distanceToSquared(v: Vector3): number;
+    addXYZW(x: number, y: number, z: number, w: number, target?: Vector3): Vector3;
+    clone(): Vector3;
+    copyFrom(src: Vector3): Vector3;
+    decrementBy(a: Vector3): void;
+    dotProduct(a: Vector3): number;
+    equals(toCompare: Vector3, allFour?: boolean): boolean;
+    incrementBy(a: Vector3): void;
+    divide(v: any): Vector3;
+    negate(): this;
+    normalize(thickness?: number): Vector3;
+    applyQuaternion(q: any): this;
+    applyMatrix4(m: any): Vector3;
+    scaleBy(s: number): Vector3;
+    mul(s: number): Vector3;
+    scale(s: Vector3): Vector3;
+    scaleToRef(s: number, ref: Vector3): Vector3;
+    setTo(xa: number, ya: number, za: number, wa?: number): void;
+    copy(src: Vector3): this;
+    subtract(a: Vector3, target?: Vector3): Vector3;
+    multiply(other: Vector3, target?: Vector3): Vector3;
+    divided(other: Vector3, target?: Vector3): Vector3;
+    div(v: number, target?: Vector3): Vector3;
+    lerp(v0: Vector3, v1: Vector3, t: number): void;
+    clamp(min: Vector3, max: Vector3): Vector3;
+    toString(): string;
+    normalizeToWay2D_XY(): void;
+    toArray(): number[];
+    copyToBytes(byte: DataView): void;
+    crossProduct(a: Vector3, target?: Vector3): Vector3;
+    crossVectors(a: Vector3, b: Vector3): this;
+    multiplyScalar(scalar: number): this;
+    setFromArray(array: number[], firstElementPos?: number): void;
+    divideScalar(scalar: any): this;
+    clampLength(min: number, max: number): this;
+    setScalar(value: number): this;
+    addScaledVector(v: Vector3, scale: number): Vector3;
+    private static calAngle;
+    static pointInsideTriangle(pt: Vector3, pt0: Vector3, pt1: Vector3, pt2: Vector3): boolean;
+    private static pointInsideTriangle2d;
+    private static productXY;
+    static serialize(position: Vector3): Vector3;
+}

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

@@ -0,0 +1,34 @@
+export declare class Vector4 {
+    static X_AXIS: Vector4;
+    static Y_AXIS: Vector4;
+    static Z_AXIS: Vector4;
+    static HELP_0: Vector4;
+    static HELP_1: Vector4;
+    static HELP_2: Vector4;
+    static EPSILON: number;
+    static HELP_3: Vector4;
+    static HELP_4: Vector4;
+    static HELP_5: Vector4;
+    static HELP_6: Vector4;
+    static ZERO: Vector4;
+    static ONE: Vector4;
+    static LEFT: Vector4;
+    static RIGHT: Vector4;
+    static UP: Vector4;
+    static DOWN: Vector4;
+    static BACK: Vector4;
+    static FORWARD: Vector4;
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    get width(): number;
+    get height(): number;
+    static crossVectors(a: Vector4, b: Vector4, target?: Vector4): Vector4;
+    static distance(pt1: Vector4, pt2: Vector4): number;
+    set(x: number, y: number, z: number, w: number): this;
+    multiplyScalar(scalar: number): this;
+    copyFrom(v: Vector4): this;
+    clone(): Vector4;
+}

package/dist/types/math/enum/FrameCache.d.ts

@@ -0,0 +1,6 @@
+export declare class FrameCache {
+    index: number;
+    time: number;
+    timeEnd: number;
+    coeff: number[];
+}

package/dist/types/math/enum/Keyframe.d.ts

@@ -0,0 +1,14 @@
+export declare class Keyframe {
+    serializedVersion: string;
+    time: number;
+    value: number;
+    inSlope: number;
+    outSlope: number;
+    tangentMode: number;
+    weightedMode: number;
+    inWeight: number;
+    outWeight: number;
+    constructor(time?: number, value?: number);
+    unSerialized(data: any): void;
+    unSerialized2(data: any): void;
+}

package/dist/types/math/enum/T/KeyframeT.d.ts

@@ -0,0 +1,18 @@
+import { CurveValueType } from "../../../loader/parser/prefab/prefabData/ValueParser";
+import { ValueEnumType } from "../../../loader/parser/prefab/prefabData/ValueType";
+import { BytesArray } from "../../../util/BytesArray";
+import { Keyframe } from "../Keyframe";
+export declare class KeyframeT {
+    serializedVersion: string;
+    time: number;
+    tangentMode: number;
+    weightedMode: number;
+    propertyKeyFrame: {
+        [k: number]: Keyframe;
+    };
+    constructor(time?: number);
+    getK(k: number): Keyframe;
+    split(type: ValueEnumType, value: CurveValueType, property: string): void;
+    private getKeyFrame;
+    formBytes(bytes: BytesArray): void;
+}

package/dist/types/math/enum/T/ValueOp.d.ts

@@ -0,0 +1,4 @@
+import { CurveValueType, Quaternion, Vector2, Vector3, Vector4 } from "../../..";
+export declare class ValueOp<T extends CurveValueType> {
+    static sub<T extends CurveValueType>(v1: T, v2: T): number | Vector2 | Vector4 | Vector3 | Quaternion;
+}

package/dist/types/math/enum/WrapTimeMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum WrapTimeMode {
+    PingPong = 0,
+    Repeat = 1,
+    Clamp = 2
+}

package/dist/types/math/navigation/DoubleArray.d.ts

@@ -0,0 +1,11 @@
+export declare class DoubleArray {
+    private _keys;
+    private _values;
+    getIndexByKey(key: any): number;
+    getValueByKey(key: any): any;
+    put(key: any, value: any): any;
+    remove(key: any): any;
+    getValues(): Array<any>;
+    getKeys(): Array<any>;
+    clear(): void;
+}

package/dist/types/math/navigation/Navi3DAstar.d.ts

@@ -0,0 +1,16 @@
+import { Navi3DMesh } from "./Navi3DMesh";
+import { Navi3DTriangle } from "./Navi3DTriangle";
+export declare class Navi3DAstar {
+    private _openedList;
+    private _closedList;
+    private _endNode;
+    private _startNode;
+    private _triangleChannel;
+    private _navMesh;
+    private _findIndex;
+    constructor();
+    findPath(navMesh: Navi3DMesh, startTriangle: Navi3DTriangle, endTriangle: Navi3DTriangle): boolean;
+    private search;
+    private buildPath;
+    get channel(): Array<Navi3DTriangle>;
+}

package/dist/types/math/navigation/Navi3DConst.d.ts

@@ -0,0 +1,5 @@
+export declare class Navi3DConst {
+    static SetConst(epsilon: number): void;
+    static EPSILON: number;
+    static POWER_EPSILON: number;
+}

package/dist/types/math/navigation/Navi3DEdge.d.ts

@@ -0,0 +1,33 @@
+import { Vector3 } from "../Vector3";
+import { Navi3DPoint } from "./Navi3DPoint";
+import { Navi3DPointFat } from "./Navi3DPointFat";
+import { Navi3DTriangle } from "./Navi3DTriangle";
+export declare class Navi3DEdge {
+    private _edgeMask;
+    private _edgeSize;
+    private _pointA;
+    private _pointB;
+    private _triangleOwners;
+    private _centerPoint;
+    private _edgeDirA2B;
+    crossPoint: Vector3;
+    fatPointA: Navi3DPointFat;
+    fatPointB: Navi3DPointFat;
+    private static CALC_FAT_VECTOR;
+    constructor(point0: Navi3DPoint, point1: Navi3DPoint);
+    get size(): Number;
+    get triangleOwners(): Array<Navi3DTriangle>;
+    get centerPoint(): Vector3;
+    initFatPoints(radius: number): void;
+    getFatPoint(pt: Navi3DPoint): Navi3DPointFat;
+    getAnotherFatPoint(pt: Navi3DPoint): Navi3DPointFat;
+    getAnotherPoint(pt: Navi3DPoint): Navi3DPoint;
+    containsPoint(pt: Vector3): Navi3DPoint;
+    addTriangleOwners(triangle: Navi3DTriangle): void;
+    getPublicPoint(edge: Navi3DEdge): Navi3DPoint;
+    getEqualPoint(p: Vector3): Navi3DPoint;
+    get pointA(): Navi3DPoint;
+    get pointB(): Navi3DPoint;
+    get walkAble(): boolean;
+    testMask(value: number): boolean;
+}

package/dist/types/math/navigation/Navi3DFunnel.d.ts

@@ -0,0 +1,19 @@
+import { Vector3 } from "../Vector3";
+import { Navi3DTriangle } from "./Navi3DTriangle";
+export declare class Navi3DFunnel {
+    private _aiRadius;
+    private _router;
+    private _result;
+    private _tempPublicEdgeList;
+    private _tempSamePlaneList;
+    private static CROSS_TEST_DIRECTION;
+    constructor();
+    searchPath(startPt: Vector3, endPt: Vector3, triangleList: Array<Navi3DTriangle>, radius?: number): boolean;
+    get path(): Array<Vector3>;
+    private searchEnable;
+    private search;
+    private optimusTerminusFat;
+    private pushAllPathPoint2;
+    private optimusByRadius;
+    private getFatPoint;
+}

package/dist/types/math/navigation/Navi3DMaskType.d.ts

@@ -0,0 +1,3 @@
+export declare class Navi3DMaskType {
+    static WalkAble: number;
+}

package/dist/types/math/navigation/Navi3DMesh.d.ts

@@ -0,0 +1,27 @@
+import { IQuadNode } from "../../core/tree/quad/IQuadNode";
+import { Vector3 } from "../Vector3";
+import { Navi3DEdge } from "./Navi3DEdge";
+import { Navi3DPoint } from "./Navi3DPoint";
+import { Navi3DTriangle } from "./Navi3DTriangle";
+export declare class Navi3DMesh {
+    private _nav3dPoints;
+    private _nav3dEdges;
+    private _nav3dTriangles;
+    private _path;
+    private _edgesDict;
+    private _nav3dAstar;
+    private _nav3dFunnel;
+    private _terrainQuad;
+    private _triangleList;
+    get edges(): Array<Navi3DEdge>;
+    get points(): Array<Navi3DPoint>;
+    get path(): Array<Vector3>;
+    get triangles(): Array<Navi3DTriangle>;
+    constructor(pointList: Array<Vector3>, triangleIndexList: Array<Array<number>>);
+    getTriangleAtPoint(point: Vector3, threshold?: number): IQuadNode;
+    findPath(startPt: Vector3, endPt: Vector3, aiRadius?: number): boolean;
+    private initPoints;
+    private initEdgesAndTriangles;
+    private tryCreateEdge;
+    private createConnections;
+}

package/dist/types/math/navigation/Navi3DPoint.d.ts

@@ -0,0 +1,13 @@
+import { Vector3 } from "../Vector3";
+export declare class Navi3DPoint extends Vector3 {
+    static CALC_VECTOR3D1: Vector3;
+    static CALC_VECTOR3D2: Vector3;
+    static CALC_VECTOR3D3: Vector3;
+    static CALC_VECTOR3D4: Vector3;
+    static CALC_VECTOR3D5: Vector3;
+    private _pointId;
+    constructor(id: number, X: number, Y: number, Z: number);
+    get id(): number;
+    static equalPoint(p1: Vector3, p2: Vector3): boolean;
+    static calcDistance(pt1: Vector3, pt2: Vector3): number;
+}

package/dist/types/math/navigation/Navi3DPoint2D.d.ts

@@ -0,0 +1,10 @@
+export declare class Navi3DPoint2D {
+    x: number;
+    y: number;
+    setTo(X: number, Y: number): void;
+    equals(X: number, Y: number): boolean;
+    equalPoint(pt: Navi3DPoint2D): boolean;
+    get length(): number;
+    clone(): Navi3DPoint2D;
+    normalize(): void;
+}

package/dist/types/math/navigation/Navi3DPointFat.d.ts

@@ -0,0 +1,11 @@
+import { Navi3DEdge } from "./Navi3DEdge";
+import { Navi3DPoint } from "./Navi3DPoint";
+export declare class Navi3DPointFat extends Navi3DPoint {
+    private _ownerPoint;
+    private _ownerEdge;
+    radius: number;
+    constructor(_point: Navi3DPoint, _edge: Navi3DEdge);
+    get ownerPoint(): Navi3DPoint;
+    get ownerEdge(): Navi3DEdge;
+    scalePoint(value?: number): Navi3DPointFat;
+}

package/dist/types/math/navigation/Navi3DRouter.d.ts

@@ -0,0 +1,29 @@
+import { Vector3 } from "../Vector3";
+import { Navi3DEdge } from "./Navi3DEdge";
+import { Navi3DPoint } from "./Navi3DPoint";
+export declare class Navi3DRouter {
+    endPoint: Vector3;
+    curPoint: Vector3;
+    rayA: Vector3;
+    rayB: Vector3;
+    rayAPoint: Navi3DPoint;
+    rayBPoint: Navi3DPoint;
+    static RAY_1: Vector3;
+    static RAY_2: Vector3;
+    static TEST_RAY: Vector3;
+    static TEST_RAY_1: Vector3;
+    static TEST_RAY_2: Vector3;
+    private static CALC_CROSS_POINT;
+    private static CALC_CROSS_TEST;
+    cornerPoint: Navi3DPoint;
+    cornerEdge: Navi3DEdge;
+    continuePass(fromPt: Vector3, endPt: Vector3, fromEdge: Navi3DEdge): void;
+    passEdge(commonEdge: Navi3DEdge, nextCommonEdge: Navi3DEdge, targetPoint: Vector3, lastEdge: boolean): boolean;
+    private checkEndPoint;
+    calcCrossEdge(_edge: Navi3DEdge, linePoint: Vector3, lineDirection: Vector3): Vector3;
+    calcCrossPoint(segmentPt1: Vector3, segmentPt2: Vector3, linePoint: Vector3, lineDirection: Vector3): Vector3;
+    calcCrossPointOut(segmentPt1: Vector3, segmentPt2: Vector3, linePoint: Vector3, lineDirection: Vector3): Vector3;
+    hasCrossPoint(segmentPt1: Vector3, segmentPt2: Vector3, linePoint: Vector3, lineDirection: Vector3): boolean;
+    private isPointAtCenter;
+    resetData(): void;
+}

package/dist/types/math/navigation/Navi3DTriangle.d.ts

@@ -0,0 +1,44 @@
+import { IQuadNode } from "../../core/tree/quad/IQuadNode";
+import { QuadAABB } from "../../core/tree/quad/QuadAABB";
+import { Plane3D } from "../Plane3D";
+import { Vector3 } from "../Vector3";
+import { Navi3DEdge } from "./Navi3DEdge";
+import { Navi3DPoint } from "./Navi3DPoint";
+export declare class Navi3DTriangle extends Vector3 implements IQuadNode {
+    private _id;
+    private _plane;
+    private _points;
+    private _edges;
+    private _neibourTriangles;
+    private _pointAgainstEdge;
+    private _edgeAgainstPoint;
+    private _mask;
+    private _aabbBox;
+    f: number;
+    gg: number;
+    h: number;
+    parent: Navi3DTriangle;
+    costMultiplier: number;
+    openId: number;
+    closeId: number;
+    get aabb(): QuadAABB;
+    initAABB(): void;
+    calcGlobalQuadAABB(): void;
+    get isTriangle(): boolean;
+    constructor(Id: number, edgeA: Navi3DEdge, edgeB: Navi3DEdge, edgeC: Navi3DEdge);
+    private genarateAgainstData;
+    get id(): number;
+    get plane(): Plane3D;
+    get points(): Array<Navi3DPoint>;
+    addNeibour(edge: Navi3DEdge, triangle: Navi3DTriangle): void;
+    getNeibourTriangles(list?: Array<Navi3DTriangle>, edgeMask?: number, triangleMask?: number): Array<Navi3DTriangle>;
+    getEdges(list?: Array<Navi3DEdge>, edgeMask?: number): Array<Navi3DEdge>;
+    get walkAble(): boolean;
+    get edges(): Array<Navi3DEdge>;
+    testMask(value: number): boolean;
+    getEdgeAgainstPoint(edge: Navi3DEdge): Navi3DPoint;
+    getPointAgainstEdge(point: Navi3DPoint): Navi3DEdge;
+    getPublicEdge(triangle: Navi3DTriangle): Navi3DEdge;
+    loopPublicEdge(triangle: Navi3DTriangle): Navi3DEdge;
+    randomPoint(): Vector3;
+}

package/dist/types/setting/EngineSetting.d.ts

@@ -0,0 +1,23 @@
+import { ReflectionSetting } from "..";
+import { GlobalIlluminationSetting } from "./GlobalIlluminationSetting";
+import { LightSetting } from "./LightSetting";
+import { LoaderSetting } from "./LoaderSetting";
+import { MaterialSetting } from "./MaterialSetting";
+import { OcclusionQuerySetting } from "./OcclusionQuerySetting";
+import { PickSetting } from "./PickSetting";
+import { RenderSetting } from "./RenderSetting";
+import { ShadowSetting } from "./ShadowSetting";
+import { SkySetting } from "./SkySetting";
+export type EngineSetting = {
+    doublePrecision: boolean;
+    occlusionQuery: OcclusionQuerySetting;
+    pick: PickSetting;
+    render: RenderSetting;
+    sky: SkySetting;
+    shadow: ShadowSetting;
+    gi: GlobalIlluminationSetting;
+    light: LightSetting;
+    material: MaterialSetting;
+    loader: LoaderSetting;
+    reflectionSetting: ReflectionSetting;
+};

package/dist/types/setting/GlobalIlluminationSetting.d.ts

@@ -0,0 +1,115 @@
+export type GlobalIlluminationSetting = {
+    debug: boolean;
+    debugCamera?: boolean;
+    /**
+     * enable
+     */
+    enable: boolean;
+    /**
+     * offset position X of volume of GI
+     */
+    offsetX: number;
+    /**
+     * offset position Y of volume of GI
+     */
+    offsetY: number;
+    /**
+     * offset position Z of volume of GI
+     */
+    offsetZ: number;
+    /**
+     * Number of probes on the x-axis
+     */
+    probeXCount: number;
+    /**
+     * Number of probes on the y-axis
+     */
+    probeYCount: number;
+    /**
+     * Number of probes on the z-axis
+     */
+    probeZCount: number;
+    /**
+     * The size of the data sampled by a probe on the map
+     */
+    probeSize: number;
+    /**
+     * @internal
+     * The distance between probes
+     */
+    probeSpace: number;
+    /**
+     * @internal
+     * The textute size of probe
+     */
+    probeSourceTextureSize: number;
+    /**
+     * @internal
+     * Set the overall size of octahedral texture
+     */
+    octRTMaxSize: number;
+    /**
+     * @internal
+     * Set square size of each octahedral texture
+     */
+    octRTSideSize: number;
+    /**
+     * @internal
+     * Set max depth distance of probes
+     */
+    maxDistance: number;
+    /**
+     * @internal
+     */
+    normalBias: number;
+    /**
+     * @internal
+     */
+    depthSharpness: number;
+    /**
+     * @internal
+     */
+    hysteresis: number;
+    /**
+     * @internal
+     * Set hysteresis value (default 0.01)
+     */
+    lerpHysteresis: number;
+    /**
+     * @internal
+     */
+    irradianceChebyshevBias: number;
+    /**
+     * @internal
+     */
+    rayNumber: number;
+    /**
+     * @internal
+     */
+    irradianceDistanceBias: number;
+    /**
+     * Illumination intensity of indirect light
+     */
+    indirectIntensity: number;
+    /**
+     *
+     */
+    ddgiGamma: number;
+    /**
+     * The intensity of light rebound
+     */
+    bounceIntensity: number;
+    /**
+     * @internal
+     * Set probe roughness
+     */
+    probeRoughness: number;
+    /**
+     * Set whether to use real-time update GI
+     */
+    realTimeGI: boolean;
+    /**
+     * Set whether the probe automatically render scene
+     */
+    autoRenderProbe: boolean;
+};

package/dist/types/setting/LightSetting.d.ts

@@ -0,0 +1,3 @@
+export type LightSetting = {
+    maxLight: number;
+};

package/dist/types/setting/LoaderSetting.d.ts

@@ -0,0 +1,3 @@
+export type LoaderSetting = {
+    numConcurrent: number;
+};

package/dist/types/setting/MaterialSetting.d.ts

@@ -0,0 +1,5 @@
+export type MaterialSetting = {
+    materialChannelDebug?: boolean;
+    materialDebug?: boolean;
+    normalYFlip?: boolean;
+};

package/dist/types/setting/OcclusionQuerySetting.d.ts

@@ -0,0 +1,12 @@
+export type OcclusionQuerySetting = {
+    enable: boolean;
+    debug: boolean;
+    octree?: {
+        width: number;
+        height: number;
+        depth: number;
+        x: number;
+        y: number;
+        z: number;
+    };
+};

package/dist/types/setting/PickSetting.d.ts

@@ -0,0 +1,5 @@
+export type PickSetting = {
+    enable: boolean;
+    mode: `pixel` | `bound`;
+    detail: `mesh` | `mesh|pos` | `mesh|normal` | `mesh|pos|normal`;
+};

package/dist/types/setting/ReflectionSetting.d.ts

@@ -0,0 +1,7 @@
+export type ReflectionSetting = {
+    reflectionProbeSize: number;
+    reflectionProbeMaxCount: number;
+    width: number;
+    height: number;
+    enable: boolean;
+};