@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/loader/parser/b3dm/arrayToString.d.ts

@@ -0,0 +1 @@
+export declare function arrayToString(array: any): string;

package/dist/types/loader/parser/b3dm/readMagicBytes.d.ts

@@ -0,0 +1 @@
+export declare function readMagicBytes(bufferOrDataView: any): string;

package/dist/types/loader/parser/gis/GeoJsonParser.d.ts

@@ -0,0 +1,29 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+export declare enum GeoType {
+    Point = "Point",
+    LineString = "LineString",
+    MultiPolygon = "MultiPolygon"
+}
+export interface GeoJsonGeometryStruct {
+    type: GeoType;
+    coordinates: any;
+}
+export interface GeoJsonPropertiesStruct {
+    prop0: string;
+    prop1: any;
+}
+export interface GeoJsonNodeStruct {
+    type: string;
+    geometry: GeoJsonGeometryStruct;
+    properties: GeoJsonPropertiesStruct;
+}
+export interface GeoJsonStruct {
+    type: string;
+    features: GeoJsonNodeStruct[];
+}
+export declare class GeoJsonParser extends ParserBase {
+    static format: ParserFormat;
+    json: string;
+    parseString(data: any): Promise<void>;
+}

package/dist/types/loader/parser/gis/GeoJsonUtil.d.ts

@@ -0,0 +1,5 @@
+import { Vector3 } from "../../..";
+import { GeoJsonStruct } from "./GeoJsonParser";
+export declare class GeoJsonUtil {
+    static getPath(data: GeoJsonStruct): Vector3[][];
+}

package/dist/types/loader/parser/gltf/GLBParser.d.ts

@@ -0,0 +1,21 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+export declare class GLBHeader {
+    magic: number;
+    version: number;
+    length: number;
+}
+export declare class GLBChunk {
+    chunkLength: number;
+    chunkType: number;
+    chunkData: Uint8Array;
+}
+export declare class GLBParser extends ParserBase {
+    static format: ParserFormat;
+    private _gltf;
+    parseBuffer(buffer: ArrayBuffer): Promise<false | import("../../..").Object3D>;
+    parseJsonAndBuffer(obj: object, bin: ArrayBuffer): Promise<import("../../..").Object3D>;
+    verification(): boolean;
+    private parseHeader;
+    private parseChunk;
+}

package/dist/types/loader/parser/gltf/GLTFInfo.d.ts

@@ -0,0 +1,137 @@
+export declare class GLTF_Info {
+    asset: {
+        generator: string;
+        version: string;
+        minVersion: string;
+    };
+    accessors: GLTF_Accessors[];
+    buffers: {
+        isParsed: boolean;
+        dbuffer: any;
+        byteLength: number;
+        uri: string;
+    }[];
+    bufferViews: {
+        isParsed: boolean;
+        buffer: number;
+        byteOffset: number;
+        dbufferView: any;
+        byteStride: number;
+        byteLength: number;
+    }[];
+    materials: {
+        name: string;
+        alphaModel: string;
+        alphaCutoff: number;
+    }[];
+    meshes: GLTF_Mesh[];
+    nodes: GLTF_Node[];
+    scene: number;
+    scenes: GLTF_Scene;
+    textures: {
+        isParsed: boolean;
+        sampler: number;
+        source: number;
+        name: string;
+        dtexture: any;
+    }[];
+    cameras: any;
+    skins: any;
+    resources: {
+        [uri: string]: any;
+    };
+    images: {
+        uri: string;
+        name: string;
+        isParsed: any;
+        dsampler: any;
+        dimage: any;
+        mimeType: string;
+        bufferView: number;
+    }[];
+    samplers: {
+        minFilter: number;
+        magFilter: number;
+        wrapS: number;
+        wrapT: number;
+    }[];
+    animations: any;
+    extensions: {
+        KHR_lights_punctual: {
+            lights: GLTF_Light[];
+        };
+    };
+}
+export declare class GLTF_Scene {
+    nodes: number[];
+}
+export declare class GLTF_Light {
+    name: string;
+    type: string;
+    color: number[];
+    intensity: number;
+    range: number;
+    spot: {
+        outerConeAngle: number;
+    };
+    isParsed: boolean;
+}
+export declare class GLTF_Node {
+    name: string;
+    rotation: number[];
+    scale: number[];
+    translation: number[];
+    children: number[];
+    matrix: number[];
+    mesh: number;
+    isParsed: any;
+    dnode: any;
+    camera: any;
+    skin: any;
+    nodeId: any;
+    primitives: any;
+    extensions: any;
+    light: GLTF_Light;
+}
+export declare class GLTF_Primitives {
+    attributes: {
+        POSITION: number;
+        NORMAL: number;
+        TANGENT: number;
+        TEXCOORD_0: number;
+        TEXCOORD_1: number;
+    };
+    indices: number;
+    material: number;
+    mode: any;
+    name: any;
+    targets: any;
+    extensions: any;
+    morphTargetsRelative: boolean;
+}
+export declare class GLTF_Mesh {
+    name: string;
+    primitives: GLTF_Primitives[];
+    isParsed: any;
+    dprimitives: any;
+    weights: any;
+    extras: any;
+}
+export declare class GLTF_Accessors {
+    bufferView: number;
+    componentType: number;
+    count: number;
+    type: string;
+    max: number[];
+    min: number[];
+    isParsed: any;
+    daccessor: any;
+    normalized: any;
+    sparse: any;
+    byteOffset: number;
+    computeResult: {
+        typedArray: any;
+        arrayType: any;
+        numComponents: number;
+    };
+}

package/dist/types/loader/parser/gltf/GLTFMaterial.d.ts

@@ -0,0 +1,24 @@
+import { Texture, Vector4 } from "../../..";
+export declare class GLTFMaterial {
+    name: string;
+    defines: string[];
+    doubleSided: boolean;
+    baseColorFactor: [1, 1, 1, 1];
+    emissiveFactor: number;
+    metallicFactor: number;
+    roughnessFactor: number;
+    alphaCutoff: number;
+    enableBlend: boolean;
+    baseColorTexture: Texture;
+    metallicRoughnessTexture: Texture;
+    normalTexture: Texture;
+    occlusionTexture: Texture;
+    emissiveTexture: Texture;
+    extensions: any;
+    baseMapOffsetSize: Vector4;
+    normalMapOffsetSize: Vector4;
+    emissiveMapOffsetSize: Vector4;
+    roughnessMapOffsetSize: Vector4;
+    metallicMapOffsetSize: Vector4;
+    aoMapOffsetSize: Vector4;
+}

package/dist/types/loader/parser/gltf/GLTFParser.d.ts

@@ -0,0 +1,45 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+export declare class GLTFParser extends ParserBase {
+    static format: ParserFormat;
+    private _gltf;
+    parseJson(obj: object): Promise<import("../../..").Object3D>;
+    verification(): boolean;
+    private static _counter;
+    static getMeshNameCounter(): () => string;
+    static getModelNameCounter(): () => string;
+    static getTexCoordDefine(texNum: any): string;
+    static getVertexColorDefine(num: any): string;
+    static getBaseColorTextureDefine(): string;
+    static getMetalRoughnessDefine(): string;
+    static getNormalMapDefine(): string;
+    static getEmissiveMapDefine(): string;
+    static getOcclusionMapDefine(): string;
+    static getMorphTargetsDefine(targetNum: any): string;
+    static getMorphtargetPositionDefine(): string;
+    static getMorphtargetNormalDefine(): string;
+    static getMorphtargetTangentDefine(): string;
+    static getJointsNumDefine(num: any): string;
+    static getJointVec8Define(): string;
+    static getHasNormalDefine(): string;
+    static getHasTangentDefine(): string;
+    static getHasNormalMapDefine(): string;
+    static getAlphaMaskDefine(): string;
+    static getAlphaBlendDefine(): string;
+    static readonly defaultMaterial: {
+        name: string;
+        alphaCutoff: number;
+        alphaMode: string;
+        pbrMetallicRoughness: {
+            name: string;
+            defines: any[];
+            doubleSided: boolean;
+            baseColorFactor: number[];
+            metallicFactor: number;
+            roughnessFactor: number;
+            emissiveFactor: number[];
+        };
+    };
+    private load_gltf_bin;
+    private load_gltf_textures;
+}

package/dist/types/loader/parser/gltf/GLTFSubParser.d.ts

@@ -0,0 +1,47 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { GLTF_Info } from "./GLTFInfo";
+import { PrefabAvatarData } from "../prefab/prefabData/PrefabAvatarData";
+import { PropertyAnimationClip } from "../../../math/AnimationCurveClip";
+export declare class GLTFSubParser {
+    currentSceneName: any;
+    gltf: GLTF_Info;
+    initUrl: string;
+    private _generator;
+    private _version;
+    private _BASE64_MARKER;
+    private _cameraParser;
+    private _meshParser;
+    private _materialParser;
+    private _skinParser;
+    private _skeletonParser;
+    private _converter;
+    constructor();
+    get version(): any;
+    parse(initUrl: string, gltf: any, sceneId: any): Promise<false | {
+        rootNode: Object3D;
+        textures: any[];
+        animations: any;
+        cameras: any[];
+    }>;
+    destroy(): void;
+    private parseScene;
+    private parseNode;
+    private errorMiss;
+    private parseCamera;
+    private parseMesh;
+    parseTexture(index: number): Promise<any>;
+    parseMaterial(materialId: any): Promise<any>;
+    private parseAnimations;
+    private parseObject3D;
+    parseSkeleton(skeletonID: number): PrefabAvatarData;
+    parseSkeletonAnimation(avatarData: PrefabAvatarData, animation: any): PropertyAnimationClip;
+    private traverse;
+    private convertToNode;
+    private parseSkin;
+    parseAccessor(accessorId: any): any;
+    private getTypedArrayFromArrayBuffer;
+    parseBufferView(bufferViewId: any): any;
+    private parseBuffer;
+    private getLight;
+    private applyNodeExtensions;
+}

package/dist/types/loader/parser/gltf/GLTFSubParserCamera.d.ts

@@ -0,0 +1,7 @@
+import { GLTF_Info } from "./GLTFInfo";
+export declare class GLTFSubParserCamera {
+    protected gltf: GLTF_Info;
+    constructor(gltf: GLTF_Info);
+    parse(cameraId: any): any;
+    protected errorMiss(e: any, info?: any): void;
+}

package/dist/types/loader/parser/gltf/GLTFSubParserConverter.d.ts

@@ -0,0 +1,17 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { GLTF_Info, GLTF_Node } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export declare class GLTFSubParserConverter {
+    protected gltf: GLTF_Info;
+    protected subParser: GLTFSubParser;
+    private _testCount;
+    private _hasCastShadow;
+    constructor(subParser: GLTFSubParser);
+    convertNodeToObject3D(nodeInfo: GLTF_Node, parentNode: any): Promise<Object3D>;
+    private convertSkeletonAnim;
+    private convertLight;
+    private convertprimitives;
+    private createGeometryBase;
+    private applyMaterialExtensions;
+    private parseSkinJoints;
+}

package/dist/types/loader/parser/gltf/GLTFSubParserMaterial.d.ts

@@ -0,0 +1,10 @@
+import { GLTF_Info } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export declare class GLTFSubParserMaterial {
+    protected gltf: GLTF_Info;
+    protected subParser: GLTFSubParser;
+    constructor(subParser: GLTFSubParser);
+    parse(materialId: any): Promise<any>;
+    private parseTexture;
+    private errorMiss;
+}

package/dist/types/loader/parser/gltf/GLTFSubParserMesh.d.ts

@@ -0,0 +1,11 @@
+import { GLTF_Info } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export declare class GLTFSubParserMesh {
+    protected gltf: GLTF_Info;
+    protected subParser: GLTFSubParser;
+    constructor(subParser: GLTFSubParser);
+    parse(meshId: any): Promise<any>;
+    private parseAccessor;
+    private parseMaterial;
+    private errorMiss;
+}

package/dist/types/loader/parser/gltf/GLTFSubParserSkeleton.d.ts

@@ -0,0 +1,15 @@
+import { PrefabAvatarData, PropertyAnimationClip } from "../../..";
+import { Skeleton } from "../../../components/anim/skeletonAnim/Skeleton";
+import { SkeletonAnimationClip } from "../../../components/anim/skeletonAnim/SkeletonAnimationClip";
+import { GLTF_Info } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export declare class GLTFSubParserSkeleton {
+    protected gltf: GLTF_Info;
+    protected subParser: GLTFSubParser;
+    constructor(subParser: GLTFSubParser);
+    parse(skeletonID: number): PrefabAvatarData;
+    parseSkeletonAnimation(avatarData: PrefabAvatarData, animation: any): PropertyAnimationClip;
+    parseSkeletonAnimationOld(skeleton: Skeleton, animation: any): SkeletonAnimationClip;
+    private buildSkeleton;
+    private buildSkeletonOld;
+}

package/dist/types/loader/parser/gltf/GLTFSubParserSkin.d.ts

@@ -0,0 +1,10 @@
+import { GLTF_Info } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export declare class GLTFSubParserSkin {
+    protected gltf: GLTF_Info;
+    protected subParser: GLTFSubParser;
+    constructor(subParser: GLTFSubParser);
+    parse(skinId: any): any;
+    private parseAccessor;
+    private errorMiss;
+}

package/dist/types/loader/parser/gltf/GLTFType.d.ts

@@ -0,0 +1,22 @@
+export declare class GLTFType {
+    static readonly GLTF_NODE_INDEX_PROPERTY: "GLTF_NODE_INDEX";
+    static readonly BASE_COLOR_UNIFORM = "u_baseColorFactor";
+    static readonly BASE_COLOR_TEXTURE_UNIFORM = "u_baseColorSampler";
+    static readonly METALROUGHNESS_UNIFORM = "u_metallicRoughnessValues";
+    static readonly METALROUGHNESS_TEXTURE_UNIFORM = "u_metallicRoughnessSampler";
+    static readonly NORMAL_TEXTURE_UNIFORM = "u_normalSampler";
+    static readonly NORMAL_SCALE_UNIFORM = "u_normalScale";
+    static readonly EMISSIVE_TEXTURE_UNIFORM = "u_emissiveSampler";
+    static readonly EMISSIVE_FACTOR_UNIFORM = "u_emissiveFactor";
+    static readonly OCCLUSION_TEXTURE_UNIFORM = "u_occlusionSampler";
+    static readonly OCCLUSION_FACTOR_UNIFORM = "u_occlusionFactor";
+    static readonly MAX_MORPH_TARGETS = 8;
+    static readonly MORPH_POSITION_PREFIX = "a_morphPositions_";
+    static readonly MORPH_NORMAL_PREFIX = "a_morphNormals_";
+    static readonly MORPH_TANGENT_PREFIX = "a_morphTangents_";
+    static readonly MORPH_WEIGHT_UNIFORM = "u_morphWeights";
+    static readonly SCENE_ROOT_SKELETON = "SCENE_ROOT";
+    static readonly IDENTITY_INVERSE_BIND_MATRICES = "IDENTITY_IBM";
+    static readonly JOINT_MATRICES_UNIFORM = "u_jointMatrix";
+    static readonly ALPHA_CUTOFF_UNIFORM = "u_alphaCutoff";
+}

package/dist/types/loader/parser/gltf/TypeArray.d.ts

@@ -0,0 +1,4 @@
+export declare function getGLTypeFromTypedArrayType(typedArrayType: any): 5120 | 5121 | 5122 | 5123 | 5124 | 5125 | 5126;
+export declare function getGLTypeFromTypedArray(typedArray: any): 5120 | 5121 | 5122 | 5123 | 5124 | 5125 | 5126;
+export declare function getTypedArrayTypeFromGLType(type: any): any;
+export declare function getTypedArray(array: any, Type?: Float32ArrayConstructor): any;

package/dist/types/loader/parser/gltf/extends/KHR_draco_mesh_compression.d.ts

@@ -0,0 +1,9 @@
+import { GLTF_Primitives } from "../GLTFInfo";
+import { GLTFSubParser } from "../GLTFSubParser";
+export declare class KHR_draco_mesh_compression {
+    private static _workerCode;
+    private static _workers;
+    static apply(parser: GLTFSubParser, primitive: GLTF_Primitives): Promise<any>;
+    static unload(gltf: any): void;
+    protected static initDecoder(): Promise<string>;
+}

package/dist/types/loader/parser/gltf/extends/KHR_lights_punctual.d.ts

@@ -0,0 +1,2 @@
+export declare class KHR_lights_punctual {
+}

package/dist/types/loader/parser/gltf/extends/KHR_materials_clearcoat.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ * @group Loader
+ */
+export declare class KHR_materials_clearcoat {
+    static apply(gltf: any, dmaterial: any, tMaterial: any): void;
+}

package/dist/types/loader/parser/gltf/extends/KHR_materials_emissive_strength.d.ts

@@ -0,0 +1,3 @@
+export declare class KHR_materials_emissive_strength {
+    static apply(gltf: any, dmaterial: any, tMaterial: any): void;
+}

package/dist/types/loader/parser/gltf/extends/KHR_materials_ior.d.ts

@@ -0,0 +1,2 @@
+export declare class KHR_materials_ior {
+}

package/dist/types/loader/parser/gltf/extends/KHR_materials_unlit.d.ts

@@ -0,0 +1,3 @@
+export declare class KHR_materials_unlit {
+    static apply(gltf: any, dmaterial: any, tMaterial: any): void;
+}

package/dist/types/loader/parser/i3dm/I3DMLoader.d.ts

@@ -0,0 +1,17 @@
+import { I3DMLoaderBase } from "./I3DMLoaderBase";
+import { Matrix4 } from "../../../math/Matrix4";
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector3 } from "../../../math/Vector3";
+export declare class I3DMLoader extends I3DMLoaderBase {
+    static tempFwd: Vector3;
+    static tempUp: Vector3;
+    static tempRight: Vector3;
+    static tempPos: Vector3;
+    static tempQuat: Quaternion;
+    static tempSca: Vector3;
+    static tempMat: Matrix4;
+    adjustmentTransform: Matrix4;
+    private _gltfBuffer;
+    constructor();
+    parse(buffer: ArrayBuffer): Promise<any>;
+}

package/dist/types/loader/parser/i3dm/I3DMLoaderBase.d.ts

@@ -0,0 +1,9 @@
+import { BatchTable, FeatureTable } from "../b3dm/FeatureTable";
+export declare class I3DMLoaderBase {
+    parse(buffer: ArrayBuffer): Promise<{
+        version: number;
+        featureTable: FeatureTable;
+        batchTable: BatchTable;
+        glbBytes: Uint8Array<ArrayBuffer>;
+    }>;
+}

package/dist/types/loader/parser/kmz/3d/WayLines3D.d.ts

@@ -0,0 +1,10 @@
+import { Object3D } from "../../../../core/entities/Object3D";
+import { WaylineFile } from "../dataDef/wayline";
+export declare class WayLines3D extends Object3D {
+    static register3DRepresentation: (wayLines3D: WayLines3D) => Object3D;
+    line: Object3D;
+    constructor(wayLineFile: WaylineFile);
+    private parseWayLineFile;
+    setup3DRepresentation(): void;
+    private createMultiLine;
+}

package/dist/types/loader/parser/kmz/3d/WayPoint3D.d.ts

@@ -0,0 +1,11 @@
+import { Object3D } from "../../../../core/entities/Object3D";
+import { PointType } from "../dataDef/point";
+export declare class WayPoint3D extends Object3D {
+    static register3DRepresentation: (wayPoint3D: WayPoint3D) => Object3D;
+    positionIndex: number;
+    positionValid: boolean;
+    marker: Object3D;
+    constructor(placemark: PointType);
+    private parsePlacemark;
+    setup3DRepresentation(): void;
+}

package/dist/types/loader/parser/kmz/KMZParser.d.ts

@@ -0,0 +1,8 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+export declare class KMZParser extends ParserBase {
+    static format: ParserFormat;
+    parseBuffer(buffer: ArrayBuffer): void;
+    private parseNode;
+    verification(): boolean;
+}