@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/loader/parser/prefab/mats/shader/ReflectionShader.d.ts

@@ -0,0 +1,19 @@
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class ReflectionShader extends Shader {
+    constructor();
+    setDefault(): void;
+    set _MainTex(value: Texture);
+    set _BumpMap(value: Texture);
+    set _MaskTex(value: Texture);
+    set _UVTransform(value: Vector4);
+    set _Metallic(value: number);
+    set _Roughness(value: number);
+    set _MainColor(value: Color);
+    set _AlphaCutoff(value: number);
+    set _DoubleSidedEnable(value: number);
+    set _SurfaceType(value: number);
+    set _AlphaCutoffEnable(value: number);
+}

package/dist/types/loader/parser/prefab/mats/shader/SkyShader.d.ts

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

package/dist/types/loader/parser/prefab/mats/shader/StandShader.d.ts

@@ -0,0 +1,220 @@
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class StandShader extends Shader {
+    constructor();
+    setDefault(): void;
+    get baseMap(): Texture;
+    set baseMap(value: Texture);
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    get normalMap(): Texture;
+    set normalMap(value: Texture);
+    get doubleSide(): boolean;
+    set doubleSide(value: boolean);
+    get alphaCutoff(): any;
+    set alphaCutoff(value: any);
+    get emissiveColor(): Color;
+    set emissiveColor(value: Color);
+    get emissiveIntensity(): number;
+    set emissiveIntensity(value: number);
+    /**
+     * get transformUV1
+     */
+    get transformUV1(): Vector4;
+    /**
+     * set transformUV1
+     */
+    set transformUV1(value: Vector4);
+    /**
+     * get transformUV2
+     */
+    get uvTransform_2(): Vector4;
+    /**
+     * set transformUV2
+     */
+    set uvTransform_2(value: Vector4);
+    get depthWriteEnabled(): boolean;
+    set depthWriteEnabled(value: boolean);
+    /**
+     * get reflectivity
+     */
+    get materialF0(): Vector4;
+    /**
+     * set reflectivity
+     */
+    set materialF0(value: Vector4);
+    /**
+     * get specularColor
+     */
+    get specularColor(): Color;
+    /**specularColor
+     * set reflectivity
+     */
+    set specularColor(value: Color);
+    /**
+     * get roughness
+     */
+    get roughness(): number;
+    /**
+     * set roughness
+     */
+    set roughness(value: number);
+    /**
+     * get metallic
+     */
+    get metallic(): number;
+    /**
+     * set metallic
+     */
+    set metallic(value: number);
+    /**
+     * get Ambient Occlussion, dealing with the effect of ambient light on object occlusion
+     */
+    get ao(): number;
+    /**
+     * set Ambient Occlussion, dealing with the effect of ambient light on object occlusion
+     */
+    set ao(value: number);
+    /**
+     * get min metallic
+     */
+    get metallic_min(): number;
+    /**
+     * set min metallic
+     */
+    set metallic_min(value: number);
+    /**
+     * get max metallic
+     */
+    get metallic_max(): number;
+    /**
+     * set max metallic
+     */
+    set metallic_max(value: number);
+    /**
+     * get min roughness
+     */
+    get roughness_min(): number;
+    /**
+     * set min roughness
+     */
+    set roughness_min(value: number);
+    /**
+     * get max roughness
+     */
+    get roughness_max(): number;
+    /**
+     * set max roughness
+     */
+    set roughness_max(value: number);
+    /**
+     * Get the influence of Normal mapping on materials
+     */
+    get normalScale(): number;
+    /**
+     * Set the influence of Normal mapping on materials
+     */
+    set normalScale(value: number);
+    /**
+     * get Mask Map
+     * R_chanel -> AoMap
+     * G_chanel -> Roughness
+     * B_chanel -> Metallic
+     * A_chanel -> C
+     */
+    get maskMap(): Texture;
+    /**
+     * set Mask Map
+     * R_chanel -> AoMap
+     * G_chanel -> Roughness
+     * B_chanel -> Metallic
+     * A_chanel -> C
+     */
+    set maskMap(value: Texture);
+    /**
+     * set Ambient Occlussion Map, dealing with the effect of ambient light on object occlusion
+     */
+    set aoMap(value: Texture);
+    /**
+     * get Ambient Occlussion Map, dealing with the effect of ambient light on object occlusion
+     */
+    get aoMap(): Texture;
+    /**
+     * set clearCoatRoughnessMap
+     */
+    set clearCoatRoughnessMap(value: Texture);
+    /**
+     * get clearCoatRoughnessMap
+     */
+    get clearCoatRoughnessMap(): Texture;
+    /**
+     * get brdf query map
+     */
+    get brdfLUT(): Texture;
+    /**
+     * set brdf query map
+     */
+    set brdfLUT(value: Texture);
+    /**
+     * get emissive map
+     */
+    get emissiveMap(): Texture;
+    /**
+     * set emissive map
+     */
+    set emissiveMap(value: Texture);
+    /**
+     * set intensity of environment light or color of sampled by texture
+     */
+    set envIntensity(value: number);
+    /**
+     * get intensity of environment light or color of sampled by texture
+     */
+    get envIntensity(): number;
+    /**
+     * set factor of refractive
+     */
+    set ior(value: number);
+    /**
+     * get factor of refractive
+     */
+    get ior(): number;
+    /**
+     * valid USE_CLEARCOAT define in shader
+     */
+    useCleanCoat(): void;
+    /**
+     * Set the factor of the clearcoat
+     */
+    set clearcoatFactor(value: number);
+    /**
+     * get the factor of the clearcoat
+     */
+    get clearcoatFactor(): number;
+    /**
+     * set the factor of the clearcoat Roughness
+     */
+    set clearcoatRoughnessFactor(value: number);
+    /**
+     * get the factor of the clearcoat Roughness
+     */
+    get clearcoatRoughnessFactor(): number;
+    /**
+     * set the weight of the clearcoat
+     */
+    set clearcoatWeight(value: number);
+    /**
+     * get the weight of the clearcoat
+     */
+    get clearcoatWeight(): number;
+    /**
+     * get the color of the clearcoat
+     */
+    set clearcoatColor(value: Color);
+    /**
+     * set the color of the clearcoat
+     */
+    get clearcoatColor(): Color;
+}

package/dist/types/loader/parser/prefab/mats/shader/UnLitShader.d.ts

@@ -0,0 +1,19 @@
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class UnLitShader extends Shader {
+    constructor();
+    setDefault(): void;
+    set _MainTex(value: Texture);
+    set _BumpMap(value: Texture);
+    set _MaskTex(value: Texture);
+    set _UVTransform(value: Vector4);
+    set _Metallic(value: number);
+    set _Roughness(value: number);
+    set _MainColor(value: Color);
+    set _AlphaCutoff(value: number);
+    set _DoubleSidedEnable(value: number);
+    set _SurfaceType(value: number);
+    set _AlphaCutoffEnable(value: number);
+}

package/dist/types/loader/parser/prefab/mats/shader/UnLitTexArrayShader.d.ts

@@ -0,0 +1,19 @@
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class UnLitTexArrayShader extends Shader {
+    constructor();
+    setDefault(): void;
+    set _MainTex(value: Texture);
+    set _BumpMap(value: Texture);
+    set _MaskTex(value: Texture);
+    set _UVTransform(value: Vector4);
+    set _Metallic(value: number);
+    set _Roughness(value: number);
+    set _MainColor(value: Color);
+    set _AlphaCutoff(value: number);
+    set _DoubleSidedEnable(value: number);
+    set _SurfaceType(value: number);
+    set _AlphaCutoffEnable(value: number);
+}

package/dist/types/loader/parser/prefab/prefabData/BlendShapeData.d.ts

@@ -0,0 +1,11 @@
+import { BytesArray } from "../../../../util/BytesArray";
+import { BlendShapePropertyData } from "./BlendShapePropertyData";
+export declare class BlendShapeData {
+    vertexCount: number;
+    shapeNames: string[];
+    shapeIndexs: number[];
+    blendCount: number;
+    blendShapePropertyDatas: BlendShapePropertyData[];
+    blendShapeMap: Map<string, BlendShapePropertyData>;
+    formBytes(byteArray: BytesArray): BytesArray;
+}

package/dist/types/loader/parser/prefab/prefabData/BlendShapePropertyData.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../..";
+export declare class BlendShapePropertyData {
+    shapeName: string;
+    shapeIndex: number;
+    frameCount: number;
+    blendPositionList: Float32Array;
+    blendNormalList: Float32Array;
+    formBytes(byteArray: BytesArray): void;
+}

package/dist/types/loader/parser/prefab/prefabData/KVData.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../../util/BytesArray";
+import { ValueEnumType } from "./ValueType";
+export declare class KV {
+    key: string;
+    type: ValueEnumType;
+    private _data;
+    getValue<T>(): T;
+    formBytes(matBytes: BytesArray): void;
+}

package/dist/types/loader/parser/prefab/prefabData/PrefabAvatarData.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../../util/BytesArray";
+import { PrefabBoneData } from "./PrefabBoneData";
+export declare class PrefabAvatarData {
+    name: string;
+    count: number;
+    boneData: PrefabBoneData[];
+    boneMap: Map<string, PrefabBoneData>;
+    formBytes(bytes: BytesArray): void;
+}

package/dist/types/loader/parser/prefab/prefabData/PrefabBoneData.d.ts

@@ -0,0 +1,16 @@
+import { Quaternion } from "../../../../math/Quaternion";
+import { Vector3 } from "../../../../math/Vector3";
+import { BytesArray } from "../../../../util/BytesArray";
+export declare class PrefabBoneData {
+    boneName: string;
+    bonePath: string;
+    parentBoneName: string;
+    boneID: number;
+    parentBoneID: number;
+    instanceID: string;
+    parentInstanceID: string;
+    t: Vector3;
+    q: Quaternion;
+    s: Vector3;
+    formBytes(bytes: BytesArray): void;
+}

package/dist/types/loader/parser/prefab/prefabData/PrefabMeshData.d.ts

@@ -0,0 +1,19 @@
+import { Matrix4 } from "../../../..";
+import { BlendShapeData } from "./BlendShapeData";
+export declare class PrefabMeshData {
+    name: string;
+    meshName: string;
+    meshID: string;
+    vertexCount: number;
+    vertexStrip: number;
+    vertexBuffer: Float32Array;
+    indices: Uint16Array | Uint32Array;
+    attributes: {
+        attribute: string;
+        dim: number;
+        pos: number;
+    }[];
+    bones: string[];
+    bindPose: Matrix4[];
+    blendShapeData: BlendShapeData;
+}

package/dist/types/loader/parser/prefab/prefabData/PrefabNode.d.ts

@@ -0,0 +1,19 @@
+import { Quaternion } from "../../../../math/Quaternion";
+import { Vector3 } from "../../../../math/Vector3";
+import { BytesArray } from "../../../../util/BytesArray";
+import { KV } from "./KVData";
+export declare class ComData {
+    comName: string;
+    data: KV[];
+    static parser(bytesArray: BytesArray): ComData;
+}
+export declare class PrefabNode {
+    name: string;
+    parentName: string;
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    comDatas: ComData[];
+    child: PrefabNode[];
+    static parser(bytesArray: BytesArray): PrefabNode;
+}

package/dist/types/loader/parser/prefab/prefabData/PrefabTextureData.d.ts

@@ -0,0 +1,14 @@
+import { BitmapTexture2D, Vector2 } from "../../../..";
+export declare class PrefabTextureData {
+    property: string;
+    name: string;
+    texture: BitmapTexture2D;
+    texelSize: Vector2;
+    wrapModeU: number;
+    wrapModeV: number;
+    wrapModeW: number;
+    wrapMode: number;
+    anisoLevel: number;
+    dimension: number;
+    filterMode: number;
+}

package/dist/types/loader/parser/prefab/prefabData/ValueParser.d.ts

@@ -0,0 +1,16 @@
+import { GeometryBase, Material, PropertyAnimationClip, Texture } from "../../../..";
+import { Skeleton } from "../../../../components/anim/skeletonAnim/Skeleton";
+import { Color } from "../../../../math/Color";
+import { Quaternion } from "../../../../math/Quaternion";
+import { Vector2 } from "../../../../math/Vector2";
+import { Vector3 } from "../../../../math/Vector3";
+import { Vector4 } from "../../../../math/Vector4";
+import { BytesArray } from "../../../../util/BytesArray";
+import { ValueEnumType } from "./ValueType";
+export type CurveValueType = string | number | Vector2 | Vector3 | Vector4 | Quaternion | Color | boolean | Texture | Material | string[] | number[] | Float32Array | GeometryBase | Skeleton | PropertyAnimationClip[];
+export declare class ValueParser {
+    static parser(bytes: BytesArray): {
+        t: ValueEnumType;
+        v: CurveValueType;
+    };
+}

package/dist/types/loader/parser/prefab/prefabData/ValueType.d.ts

@@ -0,0 +1,35 @@
+export declare enum ValueEnumType {
+    single = 0,
+    boolean = 1,
+    int = 2,
+    int16 = 3,
+    int32 = 4,
+    float = 5,
+    long = 6,
+    uint = 7,
+    uint32 = 8,
+    uint64 = 9,
+    double = 10,
+    string = 11,
+    singleArray = 12,
+    stringArray = 13,
+    floatArray = 14,
+    vector2 = 15,
+    vector3 = 16,
+    vector4 = 17,
+    color = 18,
+    color32 = 19,
+    animationCurve = 20,
+    quaternion = 21,
+    matrix4x4 = 22,
+    mesh = 23,
+    texture = 24,
+    material = 25,
+    materials = 26,
+    skeleton = 27,
+    animClip = 28,
+    vector2Int = 29,
+    int32List = 30,
+    colorList = 31,
+    color32List = 32
+}

package/dist/types/loader/parser/tileRenderer/TileSet.d.ts

@@ -0,0 +1,45 @@
+export declare class TileSet {
+    asset: {
+        generatetool: string;
+        version: string;
+        gltfUpAxis?: any;
+    };
+    extras: {
+        scenetree: string;
+    };
+    geometricError: number;
+    properties: any;
+    refine: any;
+    root: TileSetRoot;
+}
+export declare class TileSetRoot {
+    boundingVolume: {
+        box: number[];
+    };
+    children: TileSetChild[];
+    geometricError: number;
+    transform: number[];
+}
+export declare class TileSetChild {
+    boundingVolume: {
+        box: number[];
+    };
+    geometricError: number;
+    refine: string;
+    content: {
+        uri: string;
+    };
+    contents: TileSetChildContent[];
+}
+export declare class TileSetChildContent {
+    uri: string;
+    group: number;
+    metadata: TileSetChildContentMetaData;
+}
+export declare class TileSetChildContentMetaData {
+    class: string;
+    properties: {
+        vertices: number;
+        materials: number;
+    };
+}

package/dist/types/loader/parser/tileRenderer/TilesRenderer.d.ts

@@ -0,0 +1,12 @@
+import { Object3D } from "../../../core/entities/Object3D";
+export declare class TilesRenderer {
+    readonly group: Object3D;
+    private _modelList;
+    private _tileSet;
+    private _rootPath;
+    constructor();
+    loadTileSet(rootPath: string, file: string): Promise<void>;
+    private onLoadProgress;
+    private onComplete;
+    private applyTransform;
+}

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

@@ -0,0 +1,58 @@
+export declare enum BlendMode {
+    /**
+     * Working only in WebGPU may improve the performance of large background images without alpha.
+     * The source pixel is not mixed with the target pixel, so the GPU will not read colors from the target pixel.
+     */
+    NONE = 0,
+    /**
+     * Display objects above the background. When the background is transparent,
+     * the pixel values of the displayed object are not visible.
+     */
+    ABOVE = 1,
+    /**
+     * Transparent mode
+     */
+    ALPHA = 2,
+    /**
+     * Normal blend mode
+     */
+    NORMAL = 3,
+    /**
+     * Add the values of the component colors of the displayed object to its background color
+     */
+    ADD = 4,
+    /**
+     * Add the values of the component colors of the displayed object to its background color
+     */
+    BELOW = 5,
+    /**
+     * Erase the background based on the alpha value of the displayed object.
+     */
+    ERASE = 6,
+    /**
+     * Multiply the values of the displayed object's constituent colors by the background color,
+     * and then divide by 0xFF for normalization to obtain a darker color.
+     */
+    MUL = 7,
+    /**
+     * Multiply the inverse of the components of the source and target images, and then calculate the inverse result.
+     */
+    SCREEN = 8,
+    DIVD = 9,
+    SOFT_ADD = 10
+}
+/**
+ * @internal
+ * @group Material
+ */
+export declare enum Blend {
+    src_a = 0,
+    dest_a = 1
+}
+/**
+ * @internal
+ * @group Material
+ */
+export declare class BlendFactor {
+    static getBlend(blendMode: BlendMode): any;
+}

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

@@ -0,0 +1,14 @@
+import { Material } from '..';
+/**
+ * ColorLitMaterial
+ * @group Material
+ */
+export declare class ColorLitMaterial extends Material {
+    static count: number;
+    /**
+     * @constructor
+     */
+    constructor();
+    clone(): this;
+    debug(): void;
+}

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

@@ -0,0 +1,15 @@
+import { Material } from "./Material";
+/**
+ * @internal
+ * @group Material
+ */
+export declare enum GIProbeMaterialType {
+    CastGI = 0,
+    ReceiveGI = 1,
+    CastDepth = 2,
+    Other = 3
+}
+export declare class GIProbeMaterial extends Material {
+    static count: number;
+    constructor(type?: GIProbeMaterialType, index?: number);
+}

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

@@ -0,0 +1,20 @@
+import { Material } from "./Material";
+import { Float16ArrayTexture } from "../textures/Float16ArrayTexture";
+import { Uint8ArrayTexture } from "../textures/Uint8ArrayTexture";
+import { Uint32ArrayTexture } from "../textures/Uint32ArrayTexture";
+import { Matrix4 } from "../math/Matrix4";
+export declare class GSplatMaterial extends Material {
+    constructor();
+    setSplatTextures(splatColor: Uint8ArrayTexture, transformA: Uint32ArrayTexture, transformB: Float16ArrayTexture, texParams: Float32Array, splatOrder?: Uint32ArrayTexture): void;
+    /**
+     * Set the model matrix for transforming splats to world space
+     */
+    setTransformMatrix(matrix: Matrix4): void;
+    /**
+     * Set pixel coverage culling thresholds
+     * @param minPixels Minimum pixel coverage (cull tiny splats), default: 2.0
+     * @param maxPixels Maximum pixel coverage (cull oversized splats), default: 0 (disabled)
+     * @param maxPixelCullDistance Only cull oversized splats within this distance, 0 = always cull
+     */
+    setPixelCulling(minPixels: number, maxPixels: number, maxPixelCullDistance?: number): void;
+}

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

@@ -0,0 +1,39 @@
+import { Material } from "..";
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../math/Color";
+/**
+ * Lambert Mateiral
+ * 一种无光泽的表面材质，没有镜面高光。
+ * @group Material
+ */
+export declare class LambertMaterial extends Material {
+    /**
+     * @constructor
+     */
+    constructor();
+    /**
+     * set base color map texture
+     */
+    set baseMap(tex: Texture);
+    /**
+     * get base color map 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);
+}