@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/loader/parser/kmz/dataDef/point.d.ts

@@ -0,0 +1,129 @@
+import { ActionGroupType } from './action';
+import { WaypointHeadingMode, WaypointHeadingPathMode, WaypointTurnMode } from './global';
+/**
+ * Waypoint information
+ * @memberof Placemark
+ */
+export interface PointType {
+    /**
+     * Waypoint longitude and latitude <longitude,latitude>
+     * - Note: Format here is like `<Point> <coordinates> longitude,latitude </coordinates> </Point>`
+     */
+    Point: {
+        coordinates: string;
+    };
+    /**
+     * Action group list
+     */
+    actionGroup: Array<ActionGroupType>;
+    /**
+     * Waypoint height (WGS84 ellipsoid height)
+     * - m
+     * - Note: This element is used together with `wpml:height`, both are expressions of the same position with different elevation reference planes.
+     */
+    ellipsoidHeight: string;
+    /**
+     * Waypoint execution height
+     * - m
+     * - Note: This element is only used in `waylines.wpml`. Specific elevation reference plane is declared in `wpml:executeHeightMode`.
+     */
+    executeHeight?: string;
+    /**
+     * Waypoint height (EGM96 altitude height/relative to takeoff point height/AGL relative to ground height)
+     * - m
+     * - Note: This element is used together with `wpml:ellipsoidHeight`, both are expressions of the same position with different elevation reference planes.
+     */
+    height: string;
+    /**
+     * Waypoint sequence number
+     * - [0, 65535]
+     * - Note: This ID must be unique within a wayline. This sequence number must start from 0 and increment monotonically.
+     */
+    index: string;
+    isRisky: string;
+    /**
+     * Whether to use global heading mode parameters
+     * - 0: Do not use global settings
+     * - 1: Use global settings
+     */
+    useGlobalHeadingParam: '0' | '1';
+    /**
+     * Whether to use global height
+     * - 0, 1
+     */
+    useGlobalHeight: '0' | '1';
+    /**
+     * Whether to use global flight speed
+     * - 0: Do not use global settings
+     * - 1: Use global settings
+     * - Note: The global flight speed here is `wpml:autoFlightSpeed`
+     */
+    useGlobalSpeed: '0' | '1';
+    /**
+     * Whether to use global waypoint type (global waypoint turn mode)
+     * - 0: Do not use global settings
+     * - 1: Use global settings
+     */
+    useGlobalTurnParam: '0' | '1';
+    /**
+     * Whether this segment should follow straight line
+     * - `0`: Segment trajectory is curved throughout
+     * - `1`: Segment trajectory closely follows straight line between two points
+     */
+    useStraightLine: '0' | '1';
+    /**
+     * Heading mode parameters
+     */
+    waypointHeadingParam: {
+        /**
+         * Aircraft yaw angle
+         * - °
+         * - Set target yaw angle for a waypoint and smoothly transition to the next waypoint's target yaw angle during flight.
+         * - Note: Required only when `wpml:waypointHeadingMode` is `smoothTransition`
+         */
+        waypointHeadingAngle: string;
+        /**
+         * Aircraft yaw angle mode
+         */
+        waypointHeadingMode: WaypointHeadingMode;
+        /**
+         * Aircraft yaw angle rotation direction
+         */
+        waypointHeadingPathMode: WaypointHeadingPathMode;
+    };
+    /**
+     * Waypoint flight speed
+     * - m/s
+     * - [1,15]
+     */
+    waypointSpeed: string;
+    /**
+     * Waypoint type (waypoint turn mode)
+     */
+    waypointTurnParam: {
+        /**
+         * Waypoint turn damping distance
+         * - m
+         * - (0, maximum segment length]
+         * - Note: Segment length between two waypoints must be greater than the sum of turn damping distances of both waypoints. This element defines how many meters before reaching the waypoint the aircraft should start turning.
+         */
+        waypointTurnDampingDist: string;
+        /**
+         * Waypoint type (waypoint turn mode)
+         */
+        waypointTurnMode: WaypointTurnMode;
+    };
+    /**
+     * Waypoint gimbal pitch angle
+     * - °
+     */
+    gimbalPitchAngle: string;
+    /**
+     * Waypoint SLAM position information
+     */
+    slamPositionInfo: {
+        slamPosition: string;
+        slamPositionIndex: string;
+        slamPositionValid: string;
+    };
+}

package/dist/types/loader/parser/kmz/dataDef/template.d.ts

@@ -0,0 +1,300 @@
+import { ExecuteRCLostAction, ExitOnRCLost, FinishAction, FlyToWaypointType, WaypointHeadingMode, WaypointHeadingPathMode } from './global';
+import { PointType } from './point';
+/**
+ * @description
+ * - [`template.kml`](https://developer.dji.com/doc/cloud-api-tutorial/en/api-reference/dji-wpml/template-kml.html) file consists of three parts:
+ * 1. Creation information: Mainly contains information about the wayline file itself, such as file creation and update time.
+ * 2. Mission information: Mainly contains `wpml:missionConfig` element, defining global parameters for wayline missions.
+ * 3. Template information: Mainly contains `Folder` element, defining wayline template information (such as waypoint flight, mapping aerial photography, oblique photography, strip flight, etc.). Different wayline template types contain different elements.
+ */
+export interface TemplateFile {
+    /**
+     * File creation author
+     */
+    author?: string;
+    /**
+     * File creation time (Unix Timestamp)
+     * - ms
+     */
+    createTime?: string;
+    /**
+     * File update time (Unix Timestamp)
+     * - ms
+     */
+    updateTime?: string;
+    /**
+     * Template information
+     */
+    Folder: {
+        /**
+         * Waypoint information (including waypoint longitude, latitude and height, etc.)
+         */
+        Placemark?: Array<PointType>;
+        /**
+         * Global wayline flight speed
+         * - m/s
+         * - [1,15]
+         * - Note: This element defines the target flight speed of the aircraft in the entire wayline generated by this template. If this element is additionally defined for a waypoint, the local definition will override the global definition.
+         */
+        autoFlightSpeed: string;
+        caliFlightEnable: string;
+        /**
+         * Gimbal pitch angle control mode
+         */
+        gimbalPitchMode: GimbalPitchMode;
+        /**
+         * Global wayline height (relative to takeoff point height)
+         * - m
+         */
+        globalHeight: string;
+        /**
+         * Whether global segment trajectory should closely follow straight lines
+         * - `0`: Segment trajectory is curved throughout
+         * - `1`: Segment trajectory closely follows straight line between two points
+         * - Note: Required only when `wpml:globalWaypointTurnMode` is set to `toPointAndStopWithContinuityCurvature` or `toPointAndPassWithContinuityCurvature`. If this element is additionally defined for a waypoint, the local definition will override the global definition.
+         */
+        globalUseStraightLine: '0' | '1';
+        /**
+         * Global waypoint heading mode parameters
+         */
+        globalWaypointHeadingParam: {
+            /**
+             * Aircraft yaw angle
+             * - °
+             * - Set target yaw angle for a waypoint and smoothly transition to the next waypoint's target yaw angle during flight.
+             * - Note: Required only when `wpml:waypointHeadingMode` is `smoothTransition`
+             */
+            waypointHeadingAngle: string;
+            /**
+             * Aircraft yaw angle mode
+             */
+            waypointHeadingMode: WaypointHeadingMode;
+            /**
+             * Aircraft yaw angle rotation direction
+             */
+            waypointHeadingPathMode: WaypointHeadingPathMode;
+        };
+        /**
+         * Global waypoint type (global waypoint turn mode)
+         */
+        globalWaypointTurnMode: GlobalWaypointTurnMode;
+        /**
+         * Payload settings
+         */
+        payloadParam: {
+            /**
+             * Payload focus mode
+             * - `firstPoint`: Auto focus at first waypoint
+             * - `custom`: Focus with calibrated focus value
+             */
+            focusMode: 'firstPoint' | 'custom';
+            /**
+             * Image format list
+             * - `wide`: Store wide-angle lens photos
+             * - `zoom`: Store zoom lens photos
+             * - `ir`: Store infrared lens photos
+             * - `narrow_band`: Store narrow-band lens photos
+             * - Note: To store multiple lens photos, format like `<wpml:imageFormat>wide,ir</wpml:imageFormat>`
+             */
+            imageFormat: string;
+            /**
+             * Payload metering mode
+             * - `average`: Global metering
+             * - `spot`: Spot metering
+             */
+            meteringMode: 'average' | 'spot';
+            /**
+             * Payload mounting position
+             * - `0`: Aircraft mounting position 1. For M300 RTK, M350 RTK models, corresponds to front left of fuselage. For other models, corresponds to main gimbal.
+             * - `1`: Aircraft mounting position 2. For M300 RTK, M350 RTK models, corresponds to front right of fuselage.
+             * - `2`: Aircraft mounting position 3. For M300 RTK, M350 RTK models, corresponds to top of fuselage.
+             */
+            payloadPositionIndex: '0';
+            /**
+             * LiDAR return mode
+             * - `singleReturnStrongest`: Single return
+             * - `dualReturn`: Dual return
+             * - `tripleReturn`: Triple return
+             */
+            returnMode: 'singleReturnStrongest' | 'dualReturn' | 'tripleReturn';
+            /**
+             * Payload sampling rate
+             * - Hz
+             * - 60000,80000,120000,160000,180000,240000
+             */
+            samplingRate: string;
+            /**
+             * Payload scanning mode
+             * - `repetitive`: Repetitive scanning
+             * - `nonRepetitive`: Non-repetitive scanning
+             */
+            scanningMode: 'repetitive' | 'nonRepetitive';
+        };
+        /**
+         * Template ID
+         * - [0, 65535]
+         * - integer
+         * - Note: This ID must be unique within a kmz file. It is recommended to start from 0 and increment monotonically. In template.kml and waylines.wpml files, this id will be used to associate the template with the generated executable wayline.
+         */
+        templateId: string;
+        /**
+         * Predefined template type
+         * - Note: Templates provide users with a quick way to generate waylines. Users fill in template elements and import them into DJI-supported clients (such as DJI Pilot) to quickly generate executable mapping/inspection waylines.
+         */
+        templateType: TemplateType;
+        /**
+         * Coordinate system parameters
+         */
+        waylineCoordinateSysParam: {
+            /**
+             * Longitude and latitude coordinate system
+             * - `WGS84`: Currently fixed to use WGS84 coordinate system
+             */
+            coordinateMode: 'WGS84';
+            /**
+             * Waypoint elevation reference plane
+             * - `EGM96`: Use altitude height editing
+             * - `relativeToStartPoint`: Use relative point height for editing
+             * - `aboveGroundLevel`: Use terrain data, AGL editing (only supported on 司空2 platform)
+             * - `realTimeFollowSurface`: Use real-time terrain following mode (only for mapping aerial photography template), only supports M3E/M3T/M3M models
+             */
+            heightMode: 'EGM96' | 'relativeToStartPoint' | 'aboveGroundLevel' | 'realTimeFollowSurface';
+        };
+    };
+    /**
+     * Mission information
+     */
+    missionConfig: {
+        /**
+         * Aircraft model information
+         * @example 67 - 1 | M30T triple camera
+         */
+        droneInfo: {
+            /**
+             * Aircraft model main type
+             * - `89` (Model: M350 RTK),
+             * - `60` (Model: M300 RTK),
+             * - `67` (Model: M30/M30T),
+             * - `77` (Model: M3E/M3T/M3M),
+             * - `91` (Model: M3D/M3TD)
+             */
+            droneEnumValue: string;
+            /**
+             * Aircraft model sub type
+             * - When `aircraft model main type` is `67` (Model: M30/M30T):
+             *   - `0` (Model: M30 dual camera),
+             *   - `1` (Model: M30T triple camera)
+             * - When `aircraft model main type` is `77` (Model: M3E/M3T/M3M):
+             *   - `0` (Model: M3E)
+             *   - `1` (Model: M3T)
+             *   - `2` (Model: M3M)
+             * - When `aircraft model main type` is `91` (Model: M3D/M3TD):
+             *   - `0` (Model: M3D)
+             *   - `1` (Model: M3TD)
+             */
+            droneSubEnumValue: string;
+        };
+        /**
+         * Lost control action type
+         */
+        executeRCLostAction: ExecuteRCLostAction;
+        /**
+         * Whether to continue wayline execution when lost control
+         */
+        exitOnRCLost: ExitOnRCLost;
+        /**
+         * Wayline end action
+         */
+        finishAction: FinishAction;
+        /**
+         * Fly to first waypoint mode
+         */
+        flyToWaylineMode: FlyToWaypointType;
+        /**
+         * Global return home height
+         * - m
+         * - Note: When aircraft returns home, it first climbs to this height, then returns home.
+         */
+        globalRTHHeight: string;
+        /**
+         * Global wayline transition speed
+         * - m/s
+         * - [1,15]
+         * - Note: Speed of aircraft flying to the first waypoint of each wayline. Speed of aircraft recovering from current position to breakpoint when wayline mission is interrupted.
+         */
+        globalTransitionalSpeed: string;
+        /**
+         * Payload model information
+         * @example 53 - 0 | M30T triple camera, mounted on main gimbal
+         */
+        payloadInfo: {
+            /**
+             * Payload model main type
+             * - `42` (H20),
+             * - `43` (H20T),
+             * - `52` (M30 dual camera),
+             * - `53` (M30T triple camera),
+             * - `61` (H20N),
+             * - `66` (Mavic 3E camera)
+             * - `67` (Mavic 3T camera)
+             * - `68` (Mavic 3M camera)
+             * - `80` (Matrice 3D camera)
+             * - `81` (Matrice 3TD camera)
+             * - `65534` (PSDK payload)
+             */
+            payloadEnumValue: string;
+            /**
+             * Payload mounting position
+             * - `0`: Aircraft mounting position 1. For M300 RTK, M350 RTK models, corresponds to front left of fuselage. For other models, corresponds to main gimbal.
+             * - `1`: Aircraft mounting position 2. For M300 RTK, M350 RTK models, corresponds to front right of fuselage.
+             * - `2`: Aircraft mounting position 3. For M300 RTK, M350 RTK models, corresponds to top of fuselage.
+             */
+            payloadPositionIndex: string;
+            payloadSubEnumValue: string;
+        };
+        /**
+         * Reference takeoff point <x,y,z>
+         * - °, °, m
+         * - [-90,90],[-180,180], height unlimited
+         * - Note: "Reference takeoff point" is only for wayline planning reference. When aircraft executes wayline, it uses the actual takeoff point of the aircraft, and uses ellipsoid height.
+         */
+        takeOffRefPoint?: string;
+        /**
+         * Reference takeoff point altitude height
+         * - m
+         * - Note: Altitude height of "reference takeoff point", corresponding to the ellipsoid height in "reference takeoff point".
+         */
+        takeOffRefPointAGLHeight?: string;
+        /**
+         * Safe takeoff height inclined flight mode
+         * (M300) Aircraft takes off and flies inclined to first waypoint.
+         * (M30) Aircraft takes off to "safe takeoff height", then climbs inclined to first waypoint. If first waypoint height is lower than "safe takeoff height", fly horizontally first then descend.
+         * - m
+         * - [2, 1500] (Height mode: relative to takeoff point height)
+         * - Note: After aircraft takes off, it first climbs to this height, then flies to first waypoint according to "fly to first waypoint mode" settings. This element only takes effect when aircraft has not taken off.
+         */
+        takeoffSecurityHeight: string;
+    };
+}
+/**
+ * Predefined template type
+ * - `waypoint` Waypoint flight
+ * - `mapping2d` Mapping aerial photography
+ * - `mapping3d` Oblique photography
+ * - `mappingStrip` Strip flight
+ */
+export type TemplateType = 'waypoint' | 'mapping2d' | 'mapping3d' | 'mappingStrip';
+/**
+ * Global waypoint type (global waypoint turn mode)
+ * - `coordinateTurn` Coordinated turn, no waypoint passing, early turn
+ * - `toPointAndStopWithDiscontinuityCurvature` Straight flight, aircraft stops at waypoint
+ * - `toPointAndStopWithContinuityCurvature` Curved flight, aircraft stops at waypoint
+ * - `toPointAndPassWithContinuityCurvature` Curved flight, aircraft passes waypoint without stopping
+ */
+export type GlobalWaypointTurnMode = 'coordinateTurn' | 'toPointAndStopWithDiscontinuityCurvature' | 'toPointAndStopWithContinuityCurvature' | 'toPointAndPassWithContinuityCurvature';
+/**
+ * Gimbal pitch angle control mode
+ * - `manual` Manual control. During flight from one waypoint to the next, supports user manual control of gimbal pitch angle. If no user control, maintains the gimbal pitch angle when leaving the waypoint.
+ * - `usePointSetting` Follow each waypoint setting. During flight from one waypoint to the next, gimbal pitch angle smoothly transitions to the next waypoint's pitch angle.
+ */
+export type GimbalPitchMode = 'manual' | 'usePointSetting';

package/dist/types/loader/parser/kmz/dataDef/wayline.d.ts

@@ -0,0 +1,97 @@
+import { ExecuteRCLostAction, ExitOnRCLost, FinishAction, FlyToWaypointType } from './global';
+import { PointType } from './point';
+/**
+ * @description
+ * - [`waylines.wpml`](https://developer.dji.com/doc/cloud-api-tutorial/en/api-reference/dji-wpml/waylines-wpml.html) is a file directly executed by the aircraft, defining specific drone flight and payload action commands. These commands are generated by DJI Pilot 2, DJI Flighthub 2 or other software, and can also be directly edited and developed by developers. The `waylines.wpml` file consists of two parts:
+ * 1. Mission information: Mainly contains `wpml:missionConfig` element, defining global parameters for wayline missions.
+ * 2. Wayline information: Mainly contains `Folder` element, defining detailed wayline information (path definition, action definition, etc.). Each `Folder` represents an executable wayline. Specifically, when using "oblique photography" template, 5 executable waylines will be generated, corresponding to 5 `Folder` elements in `waylines.wpml`.
+ */
+export interface WaylineFile {
+    Folder: {
+        /**
+         * Waypoint information (including waypoint longitude, latitude and height, etc.)
+         */
+        Placemark: Array<PointType>;
+        /**
+         * Global wayline flight speed
+         * - m/s
+         * - [1,15]
+         * - Note: This element defines the target flight speed of the aircraft in the entire wayline generated by this template. If this element is additionally defined for a waypoint, the local definition will override the global definition.
+         */
+        autoFlightSpeed: string;
+        /**
+         * Execution height mode
+         * - `WGS84`: Ellipsoid height mode
+         * - `relativeToStartPoint`: Relative to takeoff point height mode
+         * - `realTimeFollowSurface`: Use real-time terrain following mode, only supports M3E/M3T/M3M, M3D/M3TD
+         * - Note: This element is only used in `waylines.wpml`.
+         */
+        executeHeightMode: 'WGS84' | `relativeToStartPoint` | `realTimeFollowSurface`;
+        /**
+         * Template ID
+         * - Note: This ID must be unique within a kmz file. It is recommended to start from 0 and increment monotonically. In template.kml and waylines.wpml files, this id will be used to associate the template with the generated executable wayline.
+         */
+        templateId: string;
+        /**
+         * Wayline ID
+         * - Note: This ID must be unique within a wayline. It is recommended to start from 0 and increment monotonically.
+         */
+        waylineId: string;
+    };
+    /**
+     * Mission information
+     */
+    missionConfig: {
+        /**
+         * Aircraft model information
+         */
+        droneInfo: {
+            droneEnumValue: '67';
+            droneSubEnumValue: '1';
+        };
+        /**
+         * Lost control action type
+         */
+        executeRCLostAction: ExecuteRCLostAction;
+        /**
+         * Whether to continue wayline execution when lost control
+         */
+        exitOnRCLost: ExitOnRCLost;
+        /**
+         * Wayline end action
+         */
+        finishAction: FinishAction;
+        /**
+         * Fly to first waypoint mode
+         */
+        flyToWaylineMode: FlyToWaypointType;
+        /**
+         * Global return home height
+         * - m
+         * - Note: When aircraft returns home, it first climbs to this height, then returns home.
+         */
+        globalRTHHeight: string;
+        /**
+         * Global wayline transition speed
+         * - m/s
+         * - [1,15]
+         * - Note: Speed of aircraft flying to the first waypoint of each wayline. Speed of aircraft recovering from current position to breakpoint when wayline mission is interrupted.
+         */
+        globalTransitionalSpeed: string;
+        /**
+         * Payload model information
+         */
+        payloadInfo: {
+            payloadEnumValue: '53';
+            payloadPositionIndex: '0';
+            payloadSubEnumValue: '2';
+        };
+        /**
+         * Safe takeoff height
+         * - m
+         * - [2, 1500] (Height mode: relative to takeoff point height)
+         * - Note: After aircraft takes off, it first climbs to this height, then flies to first waypoint according to "fly to first waypoint mode" settings. This element only takes effect when aircraft has not taken off.
+         */
+        takeOffSecurityHeight: string;
+    };
+}

package/dist/types/loader/parser/prefab/PrefabAvatarParser.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabAvatarParser extends ParserBase {
+    static format: ParserFormat;
+    static parser(bytesStream: BytesArray, prefabParser: PrefabParser): void;
+    verification(): boolean;
+}

package/dist/types/loader/parser/prefab/PrefabMaterialParser.d.ts

@@ -0,0 +1,9 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabMaterialParser extends ParserBase {
+    static format: ParserFormat;
+    static parserMaterial(bytesStream: BytesArray, prefabParser: PrefabParser): void;
+    verification(): boolean;
+}

package/dist/types/loader/parser/prefab/PrefabMeshParser.d.ts

@@ -0,0 +1,10 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabMeshParser extends ParserBase {
+    static format: ParserFormat;
+    parseBuffer(buffer: ArrayBuffer): Promise<void>;
+    static parserMeshs(bytesStream: BytesArray, prefabParser: PrefabParser): void;
+    verification(): boolean;
+}

package/dist/types/loader/parser/prefab/PrefabParser.d.ts

@@ -0,0 +1,16 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabAvatarData } from "./prefabData/PrefabAvatarData";
+import { PrefabNode } from "./prefabData/PrefabNode";
+export declare class PrefabParser extends ParserBase {
+    static useWebp: boolean;
+    static format: ParserFormat;
+    avatarDic: {
+        [name: string]: PrefabAvatarData;
+    };
+    nodeData: PrefabNode;
+    parseBuffer(buffer: ArrayBuffer): Promise<void>;
+    private parserPrefabNode;
+    private parserNodeTree;
+    verification(): boolean;
+}

package/dist/types/loader/parser/prefab/PrefabStringUtil.d.ts

@@ -0,0 +1,12 @@
+export declare class PrefabStringUtil {
+    static getNumber(st: string): number;
+    static getInt(st: string): number;
+    static getBoolean(st: string): boolean;
+    static getNumberArray(st: string): string;
+    static getStringArray(st: string): string[];
+    static getVector2(st: string): void;
+    static getVector3(st: string): void;
+    static getVector4(st: string): void;
+    static getQuaternion(st: string): void;
+    static getColor(st: string): void;
+}

package/dist/types/loader/parser/prefab/PrefabTextureParser.d.ts

@@ -0,0 +1,10 @@
+import { BytesArray } from "../../../util/BytesArray";
+import { LoaderFunctions } from "../../LoaderFunctions";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { PrefabParser } from "./PrefabParser";
+export declare class PrefabTextureParser extends ParserBase {
+    static format: ParserFormat;
+    static parserTexture(bytesStream: BytesArray, prefabParser: PrefabParser, loaderFunctions: LoaderFunctions): Promise<void>;
+    verification(): boolean;
+}

package/dist/types/loader/parser/prefab/mats/MaterialUtilities.d.ts

@@ -0,0 +1,8 @@
+import { Material } from "../../../../materials/Material";
+import { KV } from "../prefabData/KVData";
+import { PrefabTextureData } from "../prefabData/PrefabTextureData";
+export declare class MaterialUtilities {
+    static GetMaterial(shaderName: string): Material;
+    static applyMaterialTexture(mat: Material, textures: PrefabTextureData[]): void;
+    static applyMaterialProperties(mat: Material, properties: KV[]): void;
+}

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

@@ -0,0 +1,24 @@
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+export declare class LitSSSShader extends Shader {
+    constructor();
+    setDefault(): void;
+    set _MainTex(value: Texture);
+    set _BumpMap(value: Texture);
+    set _SSSMap(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 _SkinColor(value: Color);
+    set _SkinPower(value: number);
+    set _SkinColorIns(value: number);
+    set curveFactor(value: number);
+    set _SurfaceType(value: number);
+    set _AlphaCutoffEnable(value: number);
+}

package/dist/types/loader/parser/prefab/mats/shader/LitShader.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 LitShader 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/QuadShader.d.ts

@@ -0,0 +1,4 @@
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class QuadShader extends Shader {
+    constructor(vs?: string, fs?: string);
+}