@spatialwalk/avatarkit 1.0.0-beta.36 → 1.0.0-beta.38

package/dist/admin/src/renderSystem/renderer/webgpu/webgpuRenderer.d.ts

@@ -0,0 +1,26 @@
+import { I3DGSRenderer } from '../renderer';
+export declare class WebGPURenderer implements I3DGSRenderer {
+    private canvas;
+    private backgroundColor;
+    private device;
+    private context;
+    private renderPipeline;
+    private quadVertexBuffer;
+    private uniformBuffer;
+    private uniformBindGroup;
+    private sortIndexBuffer;
+    private splatDataBuffer;
+    private storageBindGroup;
+    private bindGroupNeedsUpdate;
+    private splatCount;
+    private presentationFormat;
+    constructor(canvas: HTMLCanvasElement, backgroundColor?: [number, number, number, number]);
+    initialize(): Promise<void>;
+    private createUniformBuffer;
+    private createQuadVertexBuffer;
+    private createRenderPipeline;
+    loadSplatsFromPackedData(packedData: Float32Array, pointCount: number, sortOrder?: Uint32Array): void;
+    render(viewMatrix: Float32Array, projectionMatrix: Float32Array, screenSize: [number, number]): void;
+    private updateUniforms;
+    dispose(): void;
+}

package/dist/admin/src/renderSystem/types/character-settings.d.ts

@@ -0,0 +1,18 @@
+export interface EyelidSettings {
+    auto_eyelid_adjustment: boolean;
+    enabled: boolean;
+    eyelid_threshold: number;
+    targets: number[];
+}
+export interface CameraSettings {
+    fovXRadians: number;
+    fovYRadians: number;
+    rotation: number;
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+}
+export interface CharacterSettings {
+    eyelid: EyelidSettings;
+    camera: CameraSettings;
+}

package/dist/admin/src/renderSystem/types/character.d.ts

@@ -0,0 +1,22 @@
+import { CameraSettings, CharacterSettings } from './character-settings';
+
+export interface CharacterMeta {
+    characterId?: string;
+    characterSettings?: CharacterSettings;
+    [key: string]: any;
+}
+export type PreloadResources<T> = {
+    version: string;
+} & T;
+export type PreloadCameraSettings = PreloadResources<{
+    camera: CameraSettings;
+}>;
+
+export declare enum ResourceType {
+    CAMERA = "camera",
+    ANIMATION_IDLE = "frameIdle",
+    MODEL_SHAPE = "shape",
+    MODEL_GS = "gsStandard"
+}
+
+export declare function extractResourceUrls(meta: CharacterMeta): Record<ResourceType, string | null>;

package/dist/admin/src/renderSystem/types/index.d.ts

@@ -0,0 +1,62 @@
+export declare enum Environment {
+    cn = "cn",
+    intl = "intl",
+    test = "test"
+}
+export declare enum DrivingServiceMode {
+
+    sdk = "sdk",
+
+    host = "host"
+}
+export interface SdkConfigResponse {
+    endpoints: {
+        cn?: string;
+        intl?: string;
+        test?: string;
+    };
+}
+export declare enum LoadProgress {
+    downloading = "downloading",
+    completed = "completed",
+    failed = "failed"
+}
+export interface LoadProgressInfo {
+    type: LoadProgress;
+    progress?: number;
+    error?: Error;
+}
+export declare enum ConnectionState {
+    disconnected = "disconnected",
+    connecting = "connecting",
+    connected = "connected",
+    failed = "failed"
+}
+export declare enum ConversationState {
+
+    idle = "idle",
+
+    playing = "playing"
+}
+export declare class SPAvatarError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export interface FlatSplatData {
+    positions: Float32Array;
+    scales: Float32Array;
+    rotations: Float32Array;
+    colors: Float32Array;
+    opacities: Float32Array;
+    pointCount: number;
+}
+export interface CameraConfig {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov: number;
+    near: number;
+    far: number;
+    up?: [number, number, number];
+    aspect?: number;
+}
+export * from './character';

package/dist/admin/src/renderSystem/utils/animation-interpolation.d.ts

@@ -0,0 +1,7 @@
+import { Flame } from '../generated/driveningress/v1/driveningress';
+
+export declare function linearLerp(from: Flame, to: Flame, progress: number): Flame;
+
+export declare function generateTransitionFrames(from: Flame, to: Flame, durationMs: number, fps?: number): Flame[];
+
+export declare function createNeutralFlame(): Flame;

package/dist/admin/src/renderSystem/utils/conversationId.d.ts

@@ -0,0 +1 @@
+export declare function generateConversationId(): string;

package/dist/admin/src/renderSystem/utils/error-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function errorToMessage(err: unknown): string;
+
+export declare function errorToDetailedMessage(err: unknown): string;

package/dist/admin/src/renderSystem/utils/id-manager.d.ts

@@ -0,0 +1,12 @@
+declare class IdManager {
+    private _connectionId;
+    private _conversationId;
+    generateConnectionId(): string;
+    getConnectionId(): string | null;
+    clearConnectionId(): void;
+    generateNewConversationId(): string;
+    getConversationId(): string | null;
+    clear(): void;
+}
+export declare const idManager: IdManager;
+export {};

package/dist/admin/src/renderSystem/utils/logger.d.ts

@@ -0,0 +1,14 @@
+export declare const logger: {
+    log: (...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    errorWithError: (message: string, error?: unknown) => void;
+};
+export declare const loggerWithUnknown: {
+    log: (...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    errorWithError: (message: string, error?: unknown) => void;
+};

package/dist/admin/src/renderSystem/wasm/avatarCoreAdapter.d.ts

@@ -0,0 +1,101 @@
+export interface WasmModuleConfig {
+    baseUrl?: string;
+    [key: string]: unknown;
+}
+export interface AvatarCoreOptions {
+    logLevel?: 'basic' | 'verbose';
+    enableValidation?: boolean;
+    enablePerformanceMetrics?: boolean;
+    retryCount?: number;
+    baseAssetsPath?: string;
+    modelFolder?: string;
+    wasmConfig?: WasmModuleConfig;
+    wasmPath?: string;
+}
+interface PerformanceMetrics {
+    initTime: number;
+    loadTime: number;
+    computeFrames: number;
+    totalComputeTime: number;
+    averageComputeTime: number;
+}
+export interface FlameInfo {
+    vertexCount: number;
+    faceCount: number;
+    jointCount: number;
+}
+export interface CharacterInfo {
+    pointCount: number;
+    hasAnimation: boolean;
+}
+export interface FlameParams {
+    shape_params?: number[];
+    expr_params?: number[];
+    rotation?: number[];
+    translation?: number[];
+    neck_pose?: number[];
+    jaw_pose?: number[];
+    eyes_pose?: number[];
+    eyelid?: number[];
+    has_eyelid?: boolean;
+}
+export declare class AvatarCoreAdapter {
+    private options;
+    private wasmConfig;
+    private wasmModule;
+    private memoryManager;
+    private coreHandle;
+    private characterHandles;
+    private animationHandles;
+    private characterHandle;
+    private animationHandle;
+    private totalFrames;
+    private isInitialized;
+    private isCharacterLoaded;
+    private api;
+    private performanceMetrics;
+    wasmTime: number;
+    private errorCodes;
+    private flameInfo?;
+    private characterInfo?;
+    constructor(options?: AvatarCoreOptions);
+    loadWASMModule(): Promise<void>;
+    private validateWASMModule;
+    private initializeMemoryViews;
+    private setupCAPIFunctions;
+    getCurrentFrameParams(frameIndex?: number, characterId?: string): Promise<FlameParams>;
+    private initializeAvatarCore;
+    loadTemplateResourcesFromBuffers(templateResources: Record<string, ArrayBuffer>): Promise<boolean>;
+    loadCharacterFromBuffers(shapeBuffer: ArrayBuffer, pointCloudBuffer: ArrayBuffer, characterId?: string): Promise<number>;
+    private loadAnimationFromData;
+    loadAnimationFromBuffer(animData: ArrayBuffer, characterId?: string): Promise<number>;
+    switchAnimationFile(animationFile: string): Promise<number>;
+    getAnimationTotalFrames(animationHandle?: number): Promise<number>;
+    getAnimationFrameParams(frameIndex?: number, characterId?: string): Promise<number>;
+    setEyeTrackingConfig(config: {
+        enabled: boolean;
+        auto_eyelid_adjustment?: boolean;
+        eyelid_threshold?: number;
+    }): Promise<boolean>;
+    setGazeTarget(x: number, y: number, z: number): Promise<boolean>;
+    resetEyeTracking(): Promise<boolean>;
+    private queryFlameInfo;
+    private queryCharacterInfo;
+    private checkError;
+    getPerformanceMetrics(): PerformanceMetrics & {
+        flameInfo?: FlameInfo;
+        characterInfo?: CharacterInfo;
+        version?: string;
+    };
+    removeCharacter(characterHandle: number, characterId?: string): void;
+    releaseCurrentCharacter(): void;
+    release(): void;
+    loadFlameModel(_modelData: any): Promise<boolean>;
+    load3DGSData(_original3DGSPoints: any, _binding: any, _flameFaces: any): Promise<boolean>;
+    computeCompleteFrameFlat(params?: {
+        frameIndex?: number;
+    }, characterHandle?: number): Promise<Float32Array | null>;
+    computeFrameFlatFromParams(flameParams: FlameParams, characterHandle?: number): Promise<Float32Array | null>;
+    getWASMMemoryMB(): number | null;
+}
+export {};

package/dist/admin/src/renderSystem/wasm/avatarCoreMemory.d.ts

@@ -0,0 +1,92 @@
+interface WASMModule {
+    _malloc: (size: number) => number;
+    _free: (ptr: number) => void;
+    writeArrayToMemory: (array: Uint8Array, ptr: number) => void;
+    HEAPU8: Uint8Array;
+    HEAP32: Int32Array;
+    HEAPF32: Float32Array;
+    getValue: (ptr: number, type: string) => number;
+    setValue: (ptr: number, value: number, type: string) => void;
+}
+interface MemoryAllocation {
+    ptr: number;
+    size: number;
+}
+export interface TemplateResources {
+    flameModel: ArrayBuffer;
+    flameTemplate: ArrayBuffer;
+    teethPb: ArrayBuffer;
+    teethNpz: ArrayBuffer;
+}
+export interface CharacterData {
+    shape: ArrayBuffer;
+    pointCloud: ArrayBuffer;
+}
+export interface ExpressionParams {
+    expression?: number[];
+    jaw?: number[];
+    eyeR?: number[];
+    eyeL?: number[];
+    pose?: number[];
+    neck?: number[];
+    translation?: number[];
+}
+export interface ArrayMetadata {
+    ptr: number;
+    size: number;
+    dtype: string;
+}
+export declare class AvatarCoreMemoryManager {
+    private module;
+    private allocatedPointers;
+    private structPointers;
+    constructor(wasmModule: WASMModule);
+    allocateAndCopy(arrayBuffer: ArrayBuffer): MemoryAllocation;
+    createTemplateConfig(resources: TemplateResources): number;
+    createCharacterData(shapeBuffer: ArrayBuffer, plyBuffer: ArrayBuffer, characterId?: string): {
+        dataPtr: number;
+        shapePtr: number;
+        plyPtr: number;
+    };
+    readFlameParams(paramsPtr: number): {
+        shape_params: number[];
+        expr_params: number[];
+        rotation: number[];
+        translation: number[];
+        neck_pose: number[];
+        jaw_pose: number[];
+        eyes_pose: number[];
+        eyelid: number[];
+        has_eyelid: boolean;
+    };
+    createFlameParams(params: {
+        shape_params?: number[];
+        expr_params?: number[];
+        rotation?: number[];
+        translation?: number[];
+        neck_pose?: number[];
+        jaw_pose?: number[];
+        eyes_pose?: number[];
+        eyelid?: number[];
+        has_eyelid?: boolean;
+    }): number;
+    readSplatPointFlatArray(arrayPtr: number): Float32Array | null;
+    readMeshData(outputPtr: number): {
+        vertices: Float32Array;
+        vertexCount: number;
+        faces: Uint32Array;
+        faceCount: number;
+        landmarks: Float32Array | null;
+        landmarkCount: number;
+        computeTime: number;
+    };
+    free(ptr: number): void;
+    freeStruct(name: string): void;
+    cleanup(): void;
+    getMemoryStats(): {
+        allocatedPointers: number;
+        structPointers: number;
+        totalAllocatedMB: number;
+    };
+}
+export {};