import { e as MMDPlayerBaseProps, f as MMDPlayerBaseRef, g as MMDPlayerEnhancedProps, h as MMDPlaylistProps, b as MMDPlaylistNode, d as MMDResources, i as MMDStage, j as MobileOptimization } from '../types-HorDyIRv.js';
export { M as MMDPlaylistConfig, a as MMDResourceItem, c as MMDResourceOptions, O as OutlineOptions, R as ResourceOption } from '../types-HorDyIRv.js';
import React__default from 'react';
import * as THREE from 'three';

/**
 * PMX模型解析器类型定义
 */
/**
 * PMX文件头信息
 */
interface PMXHeader {
    /** 文件签名 "PMX " */
    signature: string;
    /** PMX版本号 */
    version: number;
    /** 全局设置 */
    globals: {
        /** 文本编码 (0=UTF16LE, 1=UTF8) */
        encoding: number;
        /** 追加UV数 */
        additionalVec4Count: number;
        /** 顶点索引大小 */
        vertexIndexSize: number;
        /** 纹理索引大小 */
        textureIndexSize: number;
        /** 材质索引大小 */
        materialIndexSize: number;
        /** 骨骼索引大小 */
        boneIndexSize: number;
        /** Morph索引大小 */
        morphIndexSize: number;
        /** 刚体索引大小 */
        rigidBodyIndexSize: number;
    };
}
/**
 * PMX模型信息
 */
interface PMXModelInfo {
    /** 模型名称 (本地) */
    modelName: string;
    /** 模型名称 (英文) */
    modelNameEnglish: string;
    /** 注释 (本地) */
    comment: string;
    /** 注释 (英文) */
    commentEnglish: string;
}
/**
 * PMX顶点信息
 */
interface PMXVertex {
    /** 位置 */
    position: [number, number, number];
    /** 法线 */
    normal: [number, number, number];
    /** UV坐标 */
    uv: [number, number];
    /** 追加UV */
    additionalVec4?: number[][];
    /** 权重类型 */
    weightType: number;
    /** 骨骼索引 */
    boneIndices: number[];
    /** 骨骼权重 */
    boneWeights: number[];
    /** 边缘倍率 */
    edgeScale: number;
}
/**
 * PMX材质信息
 */
interface PMXMaterial {
    /** 材质名称 (本地) */
    name: string;
    /** 材质名称 (英文) */
    nameEnglish: string;
    /** 漫反射颜色 (RGBA) */
    diffuse: [number, number, number, number];
    /** 镜面反射颜色 (RGB) */
    specular: [number, number, number];
    /** 镜面反射强度 */
    specularStrength: number;
    /** 环境光颜色 (RGB) */
    ambient: [number, number, number];
    /** 绘制标志 */
    drawingFlags: number;
    /** 边缘颜色 (RGBA) */
    edgeColor: [number, number, number, number];
    /** 边缘大小 */
    edgeSize: number;
    /** 纹理索引 */
    textureIndex: number;
    /** Sphere纹理索引 */
    sphereTextureIndex: number;
    /** Sphere模式 (0=无, 1=乘, 2=加, 3=副纹理) */
    sphereMode: number;
    /** 是否使用共享Toon */
    isSharedToon: boolean;
    /** Toon纹理索引/共享Toon索引 */
    toonTextureIndex: number;
    /** 备注 */
    memo: string;
    /** 面数 */
    surfaceCount: number;
}
/**
 * PMX纹理信息
 */
interface PMXTexture {
    /** 纹理路径 */
    path: string;
    /** 纹理索引 */
    index: number;
}
/**
 * 材质与纹理的映射关系
 */
interface MaterialTextureMapping {
    /** 材质索引 */
    materialIndex: number;
    /** 材质名称 */
    materialName: string;
    /** 材质名称(英文) */
    materialNameEnglish: string;
    /** 主纹理 */
    mainTexture?: {
        index: number;
        path: string;
    };
    /** Sphere纹理 */
    sphereTexture?: {
        index: number;
        path: string;
        mode: 'multiply' | 'add' | 'subTexture';
    };
    /** Toon纹理 */
    toonTexture?: {
        index: number;
        path: string;
        isShared: boolean;
    };
    /** 面数 */
    surfaceCount: number;
}
/**
 * PMX解析结果
 */
interface PMXParseResult {
    /** 头信息 */
    header: PMXHeader;
    /** 模型信息 */
    modelInfo: PMXModelInfo;
    /** 纹理列表 */
    textures: PMXTexture[];
    /** 材质列表 */
    materials: PMXMaterial[];
    /** 材质纹理映射 */
    materialTextureMappings: MaterialTextureMapping[];
    /** 顶点数量 */
    vertexCount: number;
    /** 面数量 */
    faceCount: number;
}

/**
 * PMX模型文件解析器
 * 用于解析PMX格式的MMD模型文件，提取纹理映射关系
 */

declare class PMXParser {
    private view;
    private offset;
    private textEncoding;
    private textureIndexSize;
    private additionalVec4Count;
    private vertexIndexSize;
    private boneIndexSize;
    /**
     * 从URL加载并解析PMX文件
     */
    loadAndParse(url: string): Promise<PMXParseResult>;
    /**
     * 解析PMX文件
     */
    parse(buffer: ArrayBuffer): PMXParseResult;
    /**
     * 解析文件头
     */
    private parseHeader;
    /**
     * 解析模型信息
     */
    private parseModelInfo;
    /**
     * 跳过顶点数据（只返回数量）
     */
    private skipVertices;
    /**
     * 跳过顶点权重数据
     */
    private skipVertexWeight;
    /**
     * 跳过面数据（只返回数量）
     */
    private skipFaces;
    /**
     * 解析纹理列表
     */
    private parseTextures;
    /**
     * 解析材质列表
     */
    private parseMaterials;
    /**
     * 生成材质纹理映射
     */
    private generateMaterialTextureMappings;
    /**
     * 读取文本缓冲区
     */
    private readTextBuffer;
    /**
     * 读取固定长度字符串
     */
    private readString;
    /**
     * 读取索引
     */
    private readIndex;
}

/**
 * PMX模型编辑器
 * 支持修改材质、纹理绑定等
 */

interface PMXEditOperation {
    type: 'material' | 'texture' | 'binding';
    action: 'add' | 'update' | 'delete';
    target: number;
    data?: any;
}
interface PMXEditHistory {
    operation: PMXEditOperation;
    timestamp: number;
    description: string;
}
declare class PMXEditor$1 {
    private data;
    private history;
    private historyIndex;
    private maxHistory;
    constructor(parseResult: PMXParseResult);
    /**
     * 获取当前数据
     */
    getData(): PMXParseResult;
    /**
     * 获取编辑历史
     */
    getHistory(): PMXEditHistory[];
    /**
     * 是否可以撤销
     */
    canUndo(): boolean;
    /**
     * 是否可以重做
     */
    canRedo(): boolean;
    /**
     * 撤销
     */
    undo(): boolean;
    /**
     * 重做
     */
    redo(): boolean;
    /**
     * 添加纹理
     */
    addTexture(path: string): number;
    /**
     * 更新纹理路径
     */
    updateTexture(index: number, newPath: string): boolean;
    /**
     * 删除纹理
     */
    deleteTexture(index: number): boolean;
    /**
     * 更新材质的主纹理绑定
     */
    setMaterialMainTexture(materialIndex: number, textureIndex: number): boolean;
    /**
     * 更新材质的Sphere纹理绑定
     */
    setMaterialSphereTexture(materialIndex: number, textureIndex: number, mode?: number): boolean;
    /**
     * 更新材质的Toon纹理绑定
     */
    setMaterialToonTexture(materialIndex: number, textureIndex: number, isShared?: boolean): boolean;
    /**
     * 更新材质属性
     */
    updateMaterial(materialIndex: number, updates: Partial<PMXMaterial>): boolean;
    /**
     * 重新生成材质纹理映射
     */
    private regenerateMappings;
    /**
     * 记录历史
     */
    private recordHistory;
    /**
     * 获取统计信息
     */
    getStats(): {
        textures: number;
        materials: number;
        vertices: number;
        faces: number;
        unusedTextures: number;
        editHistory: number;
    };
    /**
     * 获取未使用的纹理
     */
    getUnusedTextures(): PMXTexture[];
}

/**
 * PMX模型导出器
 * 将编辑后的PMX数据导出为二进制文件
 */

declare class PMXExporter {
    private data;
    private buffer;
    private view;
    private offset;
    constructor(data: PMXParseResult);
    /**
     * 导出为ArrayBuffer
     */
    export(): ArrayBuffer;
    /**
     * 导出为Blob
     */
    exportAsBlob(): Blob;
    /**
     * 导出并下载
     */
    exportAndDownload(filename?: string): void;
    /**
     * 估算文件大小
     */
    private estimateSize;
    /**
     * 写入头部
     */
    private writeHeader;
    /**
     * 写入模型信息
     */
    private writeModelInfo;
    /**
     * 写入顶点占位符
     */
    private writeVertexPlaceholder;
    /**
     * 写入面占位符
     */
    private writeFacePlaceholder;
    /**
     * 写入纹理列表
     */
    private writeTextures;
    /**
     * 写入材质
     */
    private writeMaterials;
    /**
     * 写入文本缓冲区
     */
    private writeTextBuffer;
    /**
     * 写入固定长度字符串
     */
    private writeString;
    /**
     * 写入索引
     */
    private writeIndex;
}

/**
 * PMX模型编辑器组件
 * 提供可视化的材质纹理绑定编辑功能
 */

interface PMXEditorProps {
    /** PMX模型文件URL */
    modelUrl: string;
    /** 基础路径（用于拼接纹理URL） */
    basePath?: string;
    /** 自定义样式类名 */
    className?: string;
    /** 解析完成回调 */
    onParsed?: (result: PMXParseResult) => void;
    /** 错误回调 */
    onError?: (error: Error) => void;
}
declare const PMXEditor: React__default.FC<PMXEditorProps>;

/**
 * PMX模型信息查看器组件
 * 用于可视化展示PMX模型的纹理映射关系
 */

interface PMXViewerProps {
    /** PMX模型文件URL */
    modelUrl: string;
    /** 基础路径（用于拼接纹理URL） */
    basePath?: string;
    /** 自定义样式类名 */
    className?: string;
    /** 解析完成回调 */
    onParsed?: (result: PMXParseResult) => void;
    /** 错误回调 */
    onError?: (error: Error) => void;
}
declare const PMXViewer: React__default.FC<PMXViewerProps>;

declare const MMDPlayerBase: React__default.ForwardRefExoticComponent<MMDPlayerBaseProps & React__default.RefAttributes<MMDPlayerBaseRef>>;

declare const MMDPlayerEnhanced: React__default.FC<MMDPlayerEnhancedProps>;

/**
 * MMDPlaylist - 播放列表管理器
 *
 * 核心功能：
 * - 管理多个播放节点
 * - 实现无缝切换（通过 key 变化触发组件重新挂载）
 * - 预加载策略 (none / next / all)
 * - 智能内存回收
 * - 播放列表 UI
 */
declare const MMDPlaylist: React__default.FC<MMDPlaylistProps>;

interface MMDPlayerEnhancedDebugInfoProps {
    isPlaying: boolean;
    isLooping: boolean;
    isFullscreen: boolean;
    showAxes: boolean;
    isLoading: boolean;
    currentResourceId?: string;
    currentResourceName?: string;
    mode: 'single' | 'list' | 'options';
    totalResources: number;
}
declare const MMDPlayerEnhancedDebugInfo: React__default.FC<MMDPlayerEnhancedDebugInfoProps>;

interface MMDPlaylistDebugInfoProps {
    playlistName: string;
    currentIndex: number;
    currentNode: MMDPlaylistNode;
    totalNodes: number;
    isPlaying: boolean;
    isListLooping: boolean;
    isNodeLooping: boolean;
    preloadStrategy: 'none' | 'next' | 'all';
    isLoading: boolean;
    isFullscreen: boolean;
    showAxes: boolean;
    preloadedNodes: number[];
}
declare const MMDPlaylistDebugInfo: React__default.FC<MMDPlaylistDebugInfoProps>;

/**
 * MMD光照调试面板
 * 实时调整渲染器、光源、材质参数
 */

/**
 * 光照参数接口
 */
interface MMDLightingParams {
    /** 色调映射类型 (0=None, 1=Linear, 2=Reinhard, 3=Cineon, 4=ACESFilmic) */
    toneMapping: number;
    /** 色调映射曝光值 */
    toneMappingExposure: number;
    /** 环境光强度 */
    ambientIntensity: number;
    /** 主方向光强度 */
    directionalIntensity: number;
    /** 主方向光X轴位置 */
    directionalX: number;
    /** 主方向光Y轴位置 */
    directionalY: number;
    /** 主方向光Z轴位置 */
    directionalZ: number;
    /** 侧面补光强度 */
    sideIntensity: number;
    /** 半球光强度 */
    hemisphereIntensity: number;
    /** 材质自发光强度 */
    emissiveIntensity: number;
    /** 颜色亮度系数 */
    colorBrightness: number;
    /** 颜色饱和度系数 */
    colorSaturation: number;
    /** 是否启用阴影 */
    enableShadows: boolean;
    /** 模型是否接收阴影 */
    receiveShadow: boolean;
    /** 阴影偏移 */
    shadowBias: number;
    /** 高光强度（Shininess） */
    shininess: number;
    /** 高光颜色亮度 */
    specularIntensity: number;
    /** 反射率 */
    reflectivity: number;
    /** 金属度 */
    metalness: number;
    /** 粗糙度 */
    roughness: number;
    /** 环境光遮蔽强度 */
    aoMapIntensity: number;
    /** 边缘光强度 */
    rimLightIntensity: number;
    /** 边缘光颜色 */
    rimLightColor: string;
}
/**
 * 场景引用接口
 */
interface MMDSceneRefs {
    /** 渲染器 */
    renderer: THREE.WebGLRenderer | null;
    /** 环境光 */
    ambientLight: THREE.AmbientLight | null;
    /** 主方向光 */
    directionalLight: THREE.DirectionalLight | null;
    /** 侧面补光 */
    sideLight: THREE.DirectionalLight | null;
    /** 半球光 */
    hemisphereLight: THREE.HemisphereLight | null;
    /** MMD模型网格 */
    mmdMesh: THREE.SkinnedMesh | null;
}
/**
 * 组件Props
 */
interface MMDLightingDebugPanelProps {
    /** 场景引用（包含渲染器、光源、模型等） */
    sceneRefs: React__default.MutableRefObject<MMDSceneRefs>;
    /** 初始参数（可选） */
    initialParams?: Partial<MMDLightingParams>;
    /** 参数变化回调（可选） */
    onParamsChange?: (params: MMDLightingParams) => void;
    /** 是否默认显示（默认true） */
    defaultVisible?: boolean;
    /** 面板位置（默认'right'） */
    position?: 'left' | 'right';
    /** 自定义类名 */
    className?: string;
}
/**
 * MMD光照调试面板组件
 */
declare const MMDLightingDebugPanel: React__default.FC<MMDLightingDebugPanelProps>;

/**
 * Ammo.js 加载器
 * 用于异步加载 Ammo.js 物理引擎 (WASM 版本)
 */
declare global {
    interface Window {
        Ammo: any;
    }
}
/**
 * 加载 Ammo.js
 * @param path Ammo.js (WASM wrapper) 的路径，默认为 '/libs/ammo.wasm.js'
 */
declare const loadAmmo: (path?: string) => Promise<any>;

/**
 * MMD加载器优化配置
 * 用于获得接近MMD软件的渲染效果
 */

interface MMDLoaderConfig {
    /** Toon纹理路径 */
    toonPath?: string;
    /** 资源基础路径 */
    resourcePath?: string;
    /** 启用渐变贴图（用于Toon材质） */
    enableGradientMap?: boolean;
    /** 高光强度 */
    shininess?: number;
    /** 高光颜色 */
    specularColor?: THREE.ColorRepresentation;
}
/**
 * 配置MMD材质以获得最佳渲染效果
 *
 * 主要优化点：
 * 1. 为MeshToonMaterial添加渐变贴图（实现阶梯式明暗过渡）
 * 2. 调整高光参数（shininess, specular）
 * 3. 确保纹理使用正确的颜色空间
 * 4. 优化环境贴图（sphere texture）设置
 *
 * @param mesh - MMD模型网格
 * @param config - 配置选项
 */
declare function configureMaterialsForMMD(mesh: THREE.SkinnedMesh, config?: MMDLoaderConfig): void;
/**
 * 创建MMD风格的光照设置
 *
 * MMD默认使用3点光照：
 * 1. 主光源（Key Light）：从左前上方照射，强度最高
 * 2. 补光（Fill Light）：从右侧照射，减少阴影过暗
 * 3. 环境光（Ambient Light）：提供基础亮度
 *
 * @param scene - Three.js场景
 * @param options - 光照选项
 * @returns 光源对象
 */
declare function createMMDLights(scene: THREE.Scene, options?: {
    ambientIntensity?: number;
    mainIntensity?: number;
    fillIntensity?: number;
    enableShadow?: boolean;
}): {
    ambientLight: THREE.AmbientLight;
    mainLight: THREE.DirectionalLight;
    fillLight: THREE.DirectionalLight;
};
/**
 * 配置渲染器以获得MMD风格的渲染效果
 *
 * 主要配置：
 * 1. 色调映射：使用线性或无色调映射（避免过度曝光）
 * 2. 颜色空间：sRGB（与MMD一致）
 * 3. 阴影：PCF软阴影
 *
 * @param renderer - Three.js渲染器
 * @param options - 渲染器选项
 * @returns 配置后的渲染器
 */
declare function configureRendererForMMD(renderer: THREE.WebGLRenderer, options?: {
    toneMapping?: THREE.ToneMapping;
    toneMappingExposure?: number;
    enableShadow?: boolean;
}): THREE.WebGLRenderer;
/**
 * 生成Toon纹理（用于测试，如果没有原版toon01-10.bmp）
 *
 * @param index - Toon纹理索引 (1-10)
 * @returns Canvas元素
 */
declare function generateToonTexture(index: number): HTMLCanvasElement;
/**
 * 批量生成所有Toon纹理（1-10）
 *
 * @returns Toon纹理数组
 */
declare function generateAllToonTextures(): THREE.CanvasTexture[];

/**
 * MMD渲染诊断工具
 * 用于检测模型渲染问题
 */

interface MMDDiagnosticReport {
    /** 材质总数 */
    totalMaterials: number;
    /** 有Toon纹理的材质数 */
    materialsWithToon: number;
    /** 有Sphere纹理的材质数 */
    materialsWithSphere: number;
    /** 有主纹理的材质数 */
    materialsWithMainTexture: number;
    /** MeshToonMaterial数量 */
    toonMaterialCount: number;
    /** MeshPhongMaterial数量 */
    phongMaterialCount: number;
    /** MeshStandardMaterial数量 */
    standardMaterialCount: number;
    /** 问题列表 */
    issues: string[];
    /** 建议列表 */
    suggestions: string[];
}
/**
 * 诊断MMD场景渲染问题
 *
 * @param scene - Three.js场景
 * @param renderer - 渲染器（可选）
 * @returns 诊断报告
 */
declare function diagnoseMaterialsMMD(scene: THREE.Scene, renderer?: THREE.WebGLRenderer): MMDDiagnosticReport;
/**
 * 打印诊断报告到控制台
 *
 * @param report - 诊断报告
 */
declare function printDiagnosticReport(report: MMDDiagnosticReport): void;
/**
 * 快速诊断（浏览器控制台友好版本）
 *
 * 使用方法：
 * 1. 在浏览器控制台运行
 * 2. 将scene对象传入
 *
 * @param scene - Three.js场景
 * @param renderer - 渲染器（可选）
 */
declare function quickDiagnose(scene: THREE.Scene, renderer?: THREE.WebGLRenderer): void;
/**
 * 检查特定材质的详细信息
 *
 * @param material - Three.js材质
 * @returns 材质信息字符串
 */
declare function inspectMaterial(material: THREE.Material): Record<string, any>;
/**
 * 列出所有材质的详细信息
 *
 * @param scene - Three.js场景
 */
declare function listAllMaterials(scene: THREE.Scene): void;

/**
 * Sphere纹理辅助工具
 * 用于检查、诊断和修复MMD模型的sphere纹理问题
 */

/**
 * Sphere纹理诊断结果
 */
interface SphereTextureDiagnostic {
    /** 检查的材质总数 */
    totalMaterials: number;
    /** 应该有sphere纹理的材质数（根据命名推测） */
    expectedSphere: number;
    /** 实际有sphere纹理的材质数 */
    actualSphere: number;
    /** 缺少sphere纹理的材质列表 */
    missingSphere: Array<{
        index: number;
        name: string;
        objectName: string;
    }>;
    /** 可能的sphere纹理文件列表 */
    possibleSphereFiles: string[];
}
/**
 * 检查模型是否缺少sphere纹理
 *
 * @param mesh - MMD模型网格
 * @returns 诊断结果
 */
declare function checkSphereTextures(mesh: THREE.SkinnedMesh): SphereTextureDiagnostic;
/**
 * 打印sphere纹理诊断报告
 *
 * @param diagnostic - 诊断结果
 */
declare function printSphereDiagnostic(diagnostic: SphereTextureDiagnostic): void;
/**
 * 为材质添加默认的sphere纹理（临时方案）
 *
 * 注意：这只是临时方案，最好的方法是使用模型自带的sphere纹理文件
 *
 * @param mesh - MMD模型网格
 * @param sphereTextureUrl - Sphere纹理URL（可选）
 */
declare function addDefaultSphereTextures(mesh: THREE.SkinnedMesh, sphereTextureUrl?: string): void;
/**
 * 使用PMXParser检查模型定义的sphere纹理
 *
 * @param modelUrl - 模型URL
 * @returns Sphere纹理信息
 */
declare function checkModelSphereDefinition(modelUrl: string): Promise<{
    hasSphere: boolean;
    sphereTextures: Array<{
        materialName: string;
        texturePath: string;
        mode: string;
    }>;
}>;
/**
 * 打印模型的sphere纹理定义
 *
 * @param modelUrl - 模型URL
 */
declare function printModelSphereInfo(modelUrl: string): Promise<void>;
/**
 * 全面诊断sphere纹理问题
 *
 * @param mesh - 已加载的模型网格
 * @param modelUrl - 模型URL
 */
declare function fullSphereDiagnostic(mesh: THREE.SkinnedMesh, modelUrl: string): Promise<void>;

/**
 * MMD Visual Novel (Galgame 风格) 类型定义
 */

/** 单条对话/文案 */
interface DialogueLine {
    /** 唯一标识 */
    id: string;
    /** 说话者名称（可选，不填则不显示名称栏） */
    speaker?: string;
    /** 说话者名称颜色 */
    speakerColor?: string;
    /** 对话文本内容 */
    text: string;
    /** 文字显示速度（毫秒/字符），默认 50 */
    typeSpeed?: number;
    /** 是否等待用户点击才显示下一条（默认 true） */
    waitForClick?: boolean;
    /** 自动等待时间（毫秒），仅在 waitForClick 为 false 时生效 */
    autoDelay?: number;
    /** 对话时的表情/动作切换（可选） */
    expression?: string;
    /** 对话时播放的音效（可选） */
    voicePath?: string;
    /** 对话中插入的分支选项（可选，若有则显示选项） */
    choices?: DialogueChoice[];
    /** 视觉特效（可选） */
    effect?: VisualEffect;
}
/** 视觉特效配置 */
interface VisualEffect {
    /** 特效类型 */
    type: 'flash' | 'gif' | 'shake';
    /** 闪屏颜色，如 'white', 'red' */
    color?: string;
    /** 持续时间（毫秒） */
    duration?: number;
    /** GIF 动画地址 */
    url?: string;
    /** GIF 显示位置 */
    position?: 'center' | 'full';
}
/** 分支判定逻辑 */
interface BranchCondition {
    /** 变量名 */
    key: string;
    /** 变量值与节点索引的映射 */
    map: Record<string | number, number>;
    /** 默认跳转的节点索引 */
    defaultIndex: number;
}
/** 对话分支选项 */
interface DialogueChoice {
    /** 选项文字 */
    text: string;
    /** 跳转到的节点索引（可选，若不填则继续当前剧情） */
    nextNodeIndex?: number;
    /** 跳转到的对话索引（可选，默认 0） */
    nextDialogueIndex?: number;
    /** 设置变量（可选，用于后续剧情判定） */
    setVariable?: {
        key: string;
        value: string | number | boolean;
    };
    /** 选项点击后的回调（可选） */
    onSelect?: () => void;
    /** 点击选项后触发的特效（可选） */
    effect?: VisualEffect;
}
/** 视觉小说播放节点 */
interface VisualNovelNode {
    /** 唯一标识 */
    id: string;
    /** 节点名称（用于调试） */
    name?: string;
    /** MMD 资源配置（模型、动作等） */
    resources: MMDResources;
    /** 该节点的对话数组（按顺序播放） */
    dialogues: DialogueLine[];
    /** 节点特定的舞台配置（可选，覆盖全局配置） */
    stage?: MMDStage;
    /** 节点结束时的分支选项（可选，已废弃，建议使用 DialogueLine.choices） */
    choices?: DialogueChoice[];
    /** 节点结束时的分支判定逻辑（可选，根据变量跳转不同节点） */
    nextCondition?: BranchCondition;
    /** 节点开始时播放的背景音乐（可选） */
    bgmPath?: string;
    /** 背景音乐音量 0-1（默认 0.5） */
    bgmVolume?: number;
    /** 节点是否循环 MMD 动画（对话期间循环，默认 true） */
    loopAnimation?: boolean;
    /** 是否支持应援功能（默认 false） */
    supportCheer?: boolean;
}
/** 视觉小说剧本配置 */
interface VisualNovelScript {
    /** 剧本唯一标识 */
    id: string;
    /** 剧本名称 */
    name: string;
    /** 播放节点列表 */
    nodes: VisualNovelNode[];
    /** 是否在剧本结束后循环（默认 false） */
    loop?: boolean;
}
/** 对话框主题配置 */
interface DialogueBoxTheme {
    /** 对话框背景颜色 */
    backgroundColor?: string;
    /** 对话框边框颜色 */
    borderColor?: string;
    /** 对话框文字颜色 */
    textColor?: string;
    /** 说话者名称背景颜色 */
    speakerBgColor?: string;
    /** 说话者名称文字颜色 */
    speakerTextColor?: string;
    /** 对话框透明度 0-1（默认 0.85） */
    opacity?: number;
    /** 对话框模糊度（backdrop-blur，默认 8px） */
    blur?: string;
    /** 点击继续提示文字 */
    continueHint?: string;
    /** 是否显示点击继续提示（默认 true） */
    showContinueHint?: boolean;
}
/** 视觉小说组件属性 */
interface MMDVisualNovelProps {
    /** 剧本配置 */
    script: VisualNovelScript;
    /** 舞台配置 */
    stage?: MMDStage;
    /** 移动端优化配置 */
    mobileOptimization?: MobileOptimization;
    /** 对话框主题 */
    dialogueTheme?: DialogueBoxTheme;
    /** 是否自动开始（默认 true） */
    autoStart?: boolean;
    /** 开始按钮文本 */
    startText?: string;
    /** 设置按钮文本 */
    settingsText?: string;
    /** 关于按钮文本 */
    aboutText?: string;
    /** 初始节点索引（默认 0） */
    initialNodeIndex?: number;
    /** 初始对话索引（默认 0） */
    initialDialogueIndex?: number;
    /** 事件回调 */
    onNodeChange?: (node: VisualNovelNode, index: number) => void;
    onDialogueChange?: (dialogue: DialogueLine, index: number, nodeIndex: number) => void;
    onScriptComplete?: () => void;
    onError?: (error: Error) => void;
    /** 是否显示调试信息 */
    showDebugInfo?: boolean;
    /** 是否显示光照调试面板（默认false） */
    showLightingDebugPanel?: boolean;
    /** 光照调试面板初始参数 */
    lightingDebugInitialParams?: any;
    /** 是否显示快进按钮 */
    showSkipButton?: boolean;
    /** 是否显示自动播放按钮 */
    showAutoButton?: boolean;
    /** 是否显示历史记录按钮 */
    showHistoryButton?: boolean;
    /** 自定义设置面板内容 */
    customSettingsContent?: React.ReactNode;
    /** 自定义关于面板内容 */
    customAboutContent?: React.ReactNode;
    /** 样式 */
    className?: string;
    style?: React.CSSProperties;
}
/** 对话框组件属性 */
interface DialogueBoxProps {
    /** 当前对话 */
    dialogue: DialogueLine | null;
    /** 主题配置 */
    theme?: DialogueBoxTheme;
    /** 是否正在打字中 */
    isTyping?: boolean;
    /** 是否自动播放模式 */
    isAutoMode?: boolean;
    /** 点击事件 */
    onClick?: () => void;
    /** 跳过打字动画 */
    onSkipTyping?: () => void;
    /** 切换自动模式 */
    onToggleAuto?: () => void;
    /** 打开历史记录 */
    onOpenHistory?: () => void;
    /** 快进 */
    onSkip?: () => void;
    /** 重置相机 */
    onResetCamera?: () => void;
    /** 相机是否处于手动调整状态 */
    isCameraManual?: boolean;
    /** 是否显示控制按钮 */
    showControls?: boolean;
    /** 是否显示快进按钮 */
    showSkipButton?: boolean;
    /** 是否显示自动按钮 */
    showAutoButton?: boolean;
    /** 是否显示历史按钮 */
    showHistoryButton?: boolean;
    /** 样式 */
    className?: string;
}
/** 历史记录项 */
interface DialogueHistoryItem {
    nodeIndex: number;
    dialogueIndex: number;
    speaker?: string;
    text: string;
    timestamp: number;
}
/** 视觉小说组件 Ref 接口 */
interface MMDVisualNovelRef {
    /** 跳转到指定节点 */
    goToNode: (nodeIndex: number, force?: boolean) => void;
    /** 跳转到指定对话 */
    goToDialogue: (dialogueIndex: number) => void;
    /** 获取当前节点索引 */
    getCurrentNodeIndex: () => number;
    /** 获取当前对话索引 */
    getCurrentDialogueIndex: () => number;
    /** 获取对话历史 */
    getHistory: () => DialogueHistoryItem[];
    /** 获取当前剧情变量 */
    getVariables: () => Record<string, string | number | boolean>;
    /** 设置剧情变量 */
    setVariable: (key: string, value: string | number | boolean) => void;
    /** 设置自动播放模式 */
    setAutoMode: (enabled: boolean) => void;
    /** 跳过当前打字动画 */
    skipTyping: () => void;
    /** 触发视觉特效 */
    triggerEffect?: (effect: VisualEffect) => void;
}

/**
 * MMDVisualNovel - Galgame 风格视觉小说组件
 *
 * 核心功能：
 * - 将 MMDPlaylist 封装为 Galgame 风格
 * - 每个节点包含：模型、动作、对话数组
 * - 用户阅读完对话后自动切换节点
 * - 打字机效果显示文本
 * - 支持自动播放、快进、历史记录
 */
declare const MMDVisualNovel: React__default.ForwardRefExoticComponent<MMDVisualNovelProps & React__default.RefAttributes<MMDVisualNovelRef>>;

/** 模型选项 */
interface ModelOption {
    /** 唯一标识 */
    id: string;
    /** 显示名称 */
    name: string;
    /** 模型路径 */
    path: string | string[];
    /** 缩略图（可选） */
    thumbnail?: string;
}
/** 模型选择器设置属性 */
interface ModelSelectorSettingsProps {
    /** 人物模型选项列表 */
    characterModels: ModelOption[];
    /** 场景模型选项列表 */
    stageModels: ModelOption[];
    /** 当前选中的人物模型 ID */
    selectedCharacterId: string;
    /** 当前选中的场景模型 ID */
    selectedStageId: string;
    /** 人物模型选择变化回调 */
    onCharacterChange: (id: string) => void;
    /** 场景模型选择变化回调 */
    onStageChange: (id: string) => void;
    /** 人物模型标签文字 */
    characterLabel?: string;
    /** 场景模型标签文字 */
    stageLabel?: string;
}
/**
 * ModelSelectorSettings - 模型选择器设置组件
 *
 * 用于在设置界面中选择人物模型和场景模型
 */
declare const ModelSelectorSettings: React__default.FC<ModelSelectorSettingsProps>;

/** 模型选择器配置 */
interface ModelSelectorConfig {
    /** 人物模型选项列表 */
    characterModels: ModelOption[];
    /** 场景模型选项列表 */
    stageModels: ModelOption[];
    /** 默认选中的人物模型 ID（不提供则使用第一个） */
    defaultCharacterId?: string;
    /** 默认选中的场景模型 ID（不提供则使用第一个） */
    defaultStageId?: string;
    /** 人物模型标签文字 */
    characterLabel?: string;
    /** 场景模型标签文字 */
    stageLabel?: string;
}
/** 带模型选择器的视觉小说组件属性 */
interface MMDVisualNovelWithSelectorProps extends Omit<MMDVisualNovelProps, 'script'> {
    /** 基础剧本配置（模型路径会被选择器覆盖） */
    script: VisualNovelScript;
    /** 模型选择器配置 */
    modelSelector: ModelSelectorConfig;
    /** 模型选择变化回调 */
    onModelSelectionChange?: (characterId: string, stageId: string) => void;
}
/** 带模型选择器的视觉小说组件 Ref 接口 */
interface MMDVisualNovelWithSelectorRef extends MMDVisualNovelRef {
    /** 获取当前选中的人物模型 ID */
    getSelectedCharacterId: () => string;
    /** 获取当前选中的场景模型 ID */
    getSelectedStageId: () => string;
    /** 设置人物模型 */
    setCharacterModel: (id: string) => void;
    /** 设置场景模型 */
    setStageModel: (id: string) => void;
}
/**
 * MMDVisualNovelWithSelector - 带模型选择器的视觉小说组件
 *
 * 功能特性：
 * - 在设置界面中提供人物模型和场景模型的下拉选择器
 * - 选择的模型会应用到剧本中的所有节点
 * - 完全兼容 MMDVisualNovel 的所有功能
 *
 * 使用示例：
 * ```tsx
 * <MMDVisualNovelWithSelector
 *   script={myScript}
 *   modelSelector={{
 *     characterModels: [
 *       { id: 'miku', name: '初音未来', path: '/models/miku.pmx' },
 *       { id: 'luka', name: '巡音流歌', path: '/models/luka.pmx' },
 *     ],
 *     stageModels: [
 *       { id: 'stage1', name: '教室', path: '/stages/classroom.pmx' },
 *       { id: 'stage2', name: '公园', path: '/stages/park.pmx' },
 *     ],
 *   }}
 * />
 * ```
 */
declare const MMDVisualNovelWithSelector: React__default.ForwardRefExoticComponent<MMDVisualNovelWithSelectorProps & React__default.RefAttributes<MMDVisualNovelWithSelectorRef>>;

/**
 * DialogueBox - Galgame 风格对话框组件
 *
 * 功能：
 * - 打字机效果显示文本
 * - 说话者名称栏
 * - 点击继续提示
 * - 控制按钮（自动、快进、历史）
 */
declare const DialogueBox: React__default.FC<DialogueBoxProps>;

interface HistoryPanelProps {
    /** 历史记录列表 */
    history: DialogueHistoryItem[];
    /** 主题配置 */
    theme?: DialogueBoxTheme;
    /** 关闭面板 */
    onClose: () => void;
    /** 样式 */
    className?: string;
}
/**
 * HistoryPanel - 对话历史记录面板
 *
 * 显示玩家已经阅读过的所有对话
 */
declare const HistoryPanel: React__default.FC<HistoryPanelProps>;

interface LoadingOverlayProps {
    /** 是否显示加载状态 */
    isLoading?: boolean;
    /** 是否显示开始界面 */
    showStartScreen?: boolean;
    /** 脚本名称（用于开始界面） */
    scriptName?: string;
    /** 加载文本 */
    loadingText?: string;
    /** 开始按钮文本 */
    startText?: string;
    /** 设置按钮文本 */
    settingsText?: string;
    /** 关于按钮文本 */
    aboutText?: string;
    /** 点击开始回调 */
    onStart?: () => void;
    /** 自定义类名 */
    className?: string;
    /** 自定义设置面板内容 */
    customSettingsContent?: React__default.ReactNode;
    /** 自定义关于面板内容 */
    customAboutContent?: React__default.ReactNode;
}
/**
 * LoadingOverlay - 加载遮罩和开始界面组件容器
 *
 * 用于 MMD Visual Novel 的加载状态和开始界面显示
 * 组合了 LoadingScreen 和 StartScreen 两个独立组件
 */
declare const LoadingOverlay: React__default.FC<LoadingOverlayProps>;

interface LoadingScreenProps {
    /** 是否显示加载状态 */
    isLoading?: boolean;
    /** 加载文本 */
    loadingText?: string;
    /** 自定义类名 */
    className?: string;
}
/**
 * LoadingScreen - 加载界面组件
 *
 * 用于 MMD Visual Novel 的加载状态显示
 */
declare const LoadingScreen: React__default.FC<LoadingScreenProps>;

interface StartScreenProps {
    /** 是否显示开始界面 */
    showStartScreen?: boolean;
    /** 脚本名称 */
    scriptName?: string;
    /** 开始按钮文本 */
    startText?: string;
    /** 设置按钮文本 */
    settingsText?: string;
    /** 关于按钮文本 */
    aboutText?: string;
    /** 点击开始回调 */
    onStart?: () => void;
    /** 自定义类名 */
    className?: string;
    /** 自定义设置面板内容 */
    customSettingsContent?: React__default.ReactNode;
    /** 自定义关于面板内容 */
    customAboutContent?: React__default.ReactNode;
}
/**
 * StartScreen - 开始界面组件
 *
 * 用于 MMD Visual Novel 的开始界面显示
 */
declare const StartScreen: React__default.FC<StartScreenProps>;

interface ChoiceMenuProps {
    choices: DialogueChoice[];
    onSelect: (choice: DialogueChoice) => void;
    theme?: DialogueBoxTheme;
}
declare const ChoiceMenu: React__default.FC<ChoiceMenuProps>;

interface LoopConfirmDialogProps {
    onRestart: () => void;
    onBackToStart: () => void;
    onCancel?: () => void;
}
/**
 * 循环确认对话框
 * 在剧本播放到最后一个节点时，询问用户是否继续循环
 */
declare const LoopConfirmDialog: React__default.FC<LoopConfirmDialogProps>;

/**
 * 应援按钮组件
 */
interface CheerButtonProps {
    /** 点击回调 */
    onClick: () => void;
    /** 按钮文字 */
    text?: string;
    /** 是否显示 */
    show: boolean;
    /** 样式类名 */
    className?: string;
}
declare const CheerButton: React__default.FC<CheerButtonProps>;

/**
 * 3D粒子彩花效果组件
 *
 * 功能：
 * - 点击应援按钮触发粒子爆炸效果
 * - 彩色粒子从中心向外扩散
 * - 粒子受重力影响下落
 * - 自动清理完成的粒子
 */
interface CheerParticlesRef {
    /** 触发一次粒子效果 */
    trigger: () => void;
    /** 清理所有粒子 */
    clear: () => void;
}
interface CheerParticlesProps {
    /** 容器样式类名 */
    className?: string;
}
declare const CheerParticles: React__default.ForwardRefExoticComponent<CheerParticlesProps & React__default.RefAttributes<CheerParticlesRef>>;

/** 音乐曲目配置 */
interface MusicTrack {
    /** 唯一标识 */
    id: string;
    /** 歌曲名称 */
    title: string;
    /** 艺术家/歌手 */
    artist?: string;
    /** 封面图 URL */
    coverUrl?: string;
    /** MMD 资源（模型、动作、音频等） */
    resources: MMDResources;
    /** 曲目特定的舞台配置（可选，覆盖全局配置） */
    stage?: MMDStage;
    /** 预计时长（秒） */
    duration?: number;
}
/** 音乐播放器配置 */
interface MMDMusicPlayerConfig {
    /** 播放列表名称 */
    name: string;
    /** 曲目列表 */
    tracks: MusicTrack[];
    /** 是否自动播放 */
    autoPlay?: boolean;
    /** 默认循环模式 */
    defaultLoopMode?: 'list' | 'single' | 'shuffle';
}
/** 音乐播放器组件属性 */
interface MMDMusicPlayerProps {
    /** 播放配置 */
    config: MMDMusicPlayerConfig;
    /** 舞台配置 */
    stage?: MMDStage;
    /** 移动端优化配置 */
    mobileOptimization?: MobileOptimization;
    /** 初始曲目索引 */
    initialTrackIndex?: number;
    /**
     * 固定资源配置
     * 如果提供，所有曲目将使用这些指定的模型和动作，仅切换音频
     */
    fixedResources?: {
        modelPath: string;
        motionPath?: string;
        stageModelPath?: string | string[];
        cameraPath?: string;
    };
    /** 是否开启 Miku 搜索模式 */
    mikuMode?: boolean;
    /** 事件回调 */
    onTrackChange?: (track: MusicTrack, index: number) => void;
    onPlayPause?: (isPlaying: boolean) => void;
    onProgress?: (currentTime: number, duration: number) => void;
    onError?: (error: Error) => void;
    /** 样式 */
    className?: string;
    style?: React.CSSProperties;
}
/** 音乐播放器 Ref 接口 */
interface MMDMusicPlayerRef {
    /** 播放 */
    play: () => void;
    /** 暂停 */
    pause: () => void;
    /** 跳转到下一曲 */
    next: () => void;
    /** 跳转到上一曲 */
    previous: () => void;
    /** 跳转到指定曲目 */
    goToTrack: (index: number) => void;
    /** 设置循环模式 */
    setLoopMode: (mode: 'list' | 'single' | 'shuffle') => void;
    /** 获取当前状态 */
    getState: () => {
        currentIndex: number;
        isPlaying: boolean;
        currentTime: number;
        duration: number;
        loopMode: 'list' | 'single' | 'shuffle';
    };
}

/**
 * MMDMusicPlayer - MMD 音乐播放器组件 (Study with Miku 风格)
 *
 * 核心功能：
 * - 多曲目无缝切换
 * - 完整的媒体控制 (播放/暂停/进度/音量)
 * - 沉浸式 3D 舞台
 * - 自动清理内存与物理引擎
 */
declare const MMDMusicPlayer: React__default.ForwardRefExoticComponent<MMDMusicPlayerProps & React__default.RefAttributes<MMDMusicPlayerRef>>;

interface MusicControlsProps {
    isPlaying: boolean;
    currentTime: number;
    duration: number;
    loopMode: 'list' | 'single' | 'shuffle';
    isCameraManual?: boolean;
    onPlayPause: () => void;
    onNext: () => void;
    onPrevious: () => void;
    onSeek: (time: number) => void;
    onToggleLoop: () => void;
    onTogglePlaylist: () => void;
    onResetCamera?: () => void;
    className?: string;
}
declare const MusicControls: React__default.FC<MusicControlsProps>;

interface PlaylistPanelProps {
    tracks: MusicTrack[];
    currentIndex: number;
    isOpen: boolean;
    onClose: () => void;
    onSelectTrack: (index: number) => void;
    className?: string;
    mikuMode?: boolean;
    onSearch?: (keyword: string) => void;
    isSearching?: boolean;
}
declare const PlaylistPanel: React__default.FC<PlaylistPanelProps>;

interface TrackInfoProps {
    track: MusicTrack;
    className?: string;
}
declare const TrackInfo: React__default.FC<TrackInfoProps>;

interface ARPlayerProps {
    width?: number;
    height?: number;
    onReady?: () => void;
    onError?: (error: string) => void;
}
declare const MMDARPlayer: React__default.ForwardRefExoticComponent<ARPlayerProps & React__default.RefAttributes<any>>;

/**
 * AR 模式枚举
 */
declare enum ARMode {
    /**
     * 叠加模式 - 模型固定在屏幕上，跟随屏幕移动
     * 特点：简单易用，不需要陀螺仪权限
     */
    Overlay = "overlay",
    /**
     * 世界固定模式 - 真正的 AR 体验
     * 特点：模型固定在世界空间，移动设备时模型保持原位
     * 需要：设备陀螺仪/加速度计权限
     */
    WorldFixed = "world-fixed"
}
/** 预设模型配置 */
interface ModelPreset {
    /** 预设ID */
    id: string;
    /** 显示名称 */
    name: string;
    /** 缩略图URL */
    thumbnail?: string;
    /** 模型路径 (.pmx) */
    modelPath: string;
}
/** 预设动作配置 */
interface MotionPreset {
    /** 预设ID */
    id: string;
    /** 显示名称 */
    name: string;
    /** 动作路径 (.vmd) */
    motionPath: string;
}
/** 预设音乐配置 */
interface AudioPreset {
    /** 预设ID */
    id: string;
    /** 显示名称 */
    name: string;
    /** 音乐路径 */
    audioPath: string;
}
interface MMDARPlayerProps {
    /** 舞台配置 */
    stage?: MMDStage;
    /** 移动端优化配置 */
    mobileOptimization?: MobileOptimization;
    /** 摄像头配置 */
    cameraConfig?: {
        /** 偏好使用的摄像头 ('user' 为前置, 'environment' 为后置) */
        facingMode?: 'user' | 'environment';
        /** 视频分辨率 */
        width?: number | {
            min?: number;
            ideal?: number;
            max?: number;
        };
        height?: number | {
            min?: number;
            ideal?: number;
            max?: number;
        };
    };
    /** 是否开启镜像显示 (通常前置摄像头需要开启) */
    mirrored?: boolean;
    /** 是否显示设置按钮 */
    showSettings?: boolean;
    /** 预设模型列表 */
    modelPresets: ModelPreset[];
    /** 预设动作列表 */
    motionPresets: MotionPreset[];
    /** 预设音乐列表 (可选) */
    audioPresets?: AudioPreset[];
    /** 默认模型ID */
    defaultModelId?: string;
    /** 默认动作ID */
    defaultMotionId?: string;
    /** 默认音乐ID (可选) */
    defaultAudioId?: string;
    /** 初始时是否显示模型 (false 则需要点击放置) */
    initialModelVisible?: boolean;
    /** 放置按钮文案 */
    placementText?: string;
    /** AR 模式 (默认 Overlay) */
    arMode?: ARMode;
    /** 默认 AR 模式 */
    defaultARMode?: ARMode;
    /** 播放控制 */
    autoPlay?: boolean;
    loop?: boolean;
    /** 事件回调 */
    onCameraReady?: (stream: MediaStream) => void;
    onCameraError?: (error: Error) => void;
    onResourcesChange?: (resources: MMDResources) => void;
    onModelPlaced?: () => void;
    onARModeChange?: (mode: ARMode) => void;
    onLoad?: () => void;
    onError?: (error: Error) => void;
    /** 样式 */
    className?: string;
    style?: React.CSSProperties;
}
interface MMDARPlayerRef {
    /** 开启摄像头 */
    startCamera: () => Promise<void>;
    /** 关闭摄像头 */
    stopCamera: () => void;
    /** 切换摄像头 */
    switchCamera: () => Promise<void>;
    /** 截图 (包含视频背景和模型) */
    snapshot: () => Promise<string>;
    /** 放置模型 */
    placeModel: () => void;
    /** 移除模型（重置位置） */
    removeModel: () => void;
    /** 切换模型 */
    switchModel: (resources: MMDResources) => void;
    /** 切换 AR 模式 */
    setARMode: (mode: ARMode) => void;
    /** 获取当前 AR 模式 */
    getARMode: () => ARMode;
}

/**
 * FX文件解析器类型定义
 * 用于解析MME (MikuMikuEffect) 的.fx效果文件
 */
/**
 * FX文件解析结果
 */
interface FXEffect {
    /** 文件名 */
    fileName: string;
    /** 原始内容 */
    rawContent: string;
    /** 宏定义 */
    defines: FXDefine[];
    /** 参数声明 */
    parameters: FXParameter[];
    /** 静态变量 */
    staticVariables: FXStaticVariable[];
    /** 纹理引用 */
    textures: FXTexture[];
    /** 控制器引用 */
    controllers: FXController[];
    /** 包含文件 */
    includes: string[];
    /** Technique定义 */
    techniques: FXTechnique[];
    /** 着色器函数 */
    shaderFunctions: FXShaderFunction[];
    /** 注释块 */
    comments: FXComment[];
    /** 转换后的GLSL shaders（可选） */
    glslShaders?: GLSLShaders;
}
/**
 * 宏定义
 */
interface FXDefine {
    /** 宏名称 */
    name: string;
    /** 宏值 */
    value?: string;
    /** 是否被注释掉 */
    isCommented: boolean;
    /** 行号 */
    lineNumber: number;
    /** 注释说明 */
    comment?: string;
}
/**
 * 参数声明
 */
interface FXParameter {
    /** 参数类型 (float, float2, float3, float4, texture, etc.) */
    type: string;
    /** 参数名称 */
    name: string;
    /** 语义 (POSITION, TEXCOORD, DIFFUSE, etc.) */
    semantic?: string;
    /** 默认值 */
    defaultValue?: string;
    /** 注解 (annotations) */
    annotations?: Record<string, any>;
    /** 行号 */
    lineNumber: number;
    /** 注释说明 */
    comment?: string;
}
/**
 * 静态变量
 */
interface FXStaticVariable {
    /** 变量类型 */
    type: string;
    /** 变量名称 */
    name: string;
    /** 初始化表达式 */
    expression: string;
    /** 行号 */
    lineNumber: number;
}
/**
 * 纹理引用
 */
interface FXTexture {
    /** 纹理名称 */
    name: string;
    /** 纹理路径 */
    path: string;
    /** 宽度 */
    width?: number;
    /** 高度 */
    height?: number;
    /** 纹理用途 (diffuse, normal, shadow, etc.) */
    purpose?: string;
}
/**
 * 控制器引用
 */
interface FXController {
    /** 控制器名称 */
    name: string;
    /** 控制器对象 */
    objectName: string;
    /** 控制项 */
    itemName: string;
    /** 绑定到的参数 */
    boundParameter: string;
}
/**
 * Technique定义
 */
interface FXTechnique {
    /** Technique名称 */
    name: string;
    /** Pass列表 */
    passes: FXPass[];
    /** 行号 */
    lineNumber: number;
}
/**
 * Pass定义
 */
interface FXPass {
    /** Pass名称 */
    name?: string;
    /** 顶点着色器 */
    vertexShader?: {
        profile: string;
        function: string;
    };
    /** 像素着色器 */
    pixelShader?: {
        profile: string;
        function: string;
    };
    /** 渲染状态 */
    renderStates: Record<string, any>;
}
/**
 * 着色器函数
 */
interface FXShaderFunction {
    /** 函数名 */
    name: string;
    /** 返回类型 */
    returnType: string;
    /** 参数列表 */
    parameters: string;
    /** 函数体 */
    body: string;
    /** 输出语义 */
    outputSemantic?: string;
    /** 行号 */
    lineNumber: number;
}
/**
 * 注释块
 */
interface FXComment {
    /** 注释内容 */
    content: string;
    /** 注释类型 (line: 单行注释 //, block: 块注释) */
    type: 'line' | 'block';
    /** 行号 */
    lineNumber: number;
}
/**
 * 转换后的GLSL shaders
 */
interface GLSLShaders {
    /** 顶点着色器 */
    vertexShader?: GLSLShader;
    /** 片段着色器 */
    fragmentShader?: GLSLShader;
    /** 转换警告 */
    warnings: string[];
}
/**
 * GLSL shader信息
 */
interface GLSLShader {
    /** 转换后的GLSL代码 */
    code: string;
    /** Uniforms */
    uniforms: Map<string, {
        type: string;
        glslType: string;
        semantic?: string;
    }>;
    /** Attributes（仅顶点着色器） */
    attributes: Map<string, {
        type: string;
        glslType: string;
        semantic: string;
    }>;
    /** Varyings */
    varyings: Map<string, {
        type: string;
        glslType: string;
    }>;
}
/**
 * FX解析配置
 */
interface FXParserOptions {
    /** 是否保留注释 */
    keepComments?: boolean;
    /** 是否解析Technique */
    parseTechniques?: boolean;
    /** 是否解析着色器函数 */
    parseShaderFunctions?: boolean;
    /** 是否解析纹理引用 */
    parseTextures?: boolean;
    /** 是否解析控制器引用 */
    parseControllers?: boolean;
    /** 是否转换HLSL到GLSL */
    convertToGLSL?: boolean;
    /** 顶点着色器函数名（用于GLSL转换） */
    vertexShaderFunction?: string;
    /** 片段着色器函数名（用于GLSL转换） */
    fragmentShaderFunction?: string;
}
/**
 * FX文件摘要信息（用于快速预览）
 */
interface FXSummary {
    fileName: string;
    defineCount: number;
    parameterCount: number;
    textureCount: number;
    techniqueCount: number;
    hasLocalShadow: boolean;
    hasExcellentShadow: boolean;
    hasHgShadow: boolean;
    enabledDefines: string[];
    disabledDefines: string[];
}

/**
 * FX文件解析器
 * 用于解析MME (MikuMikuEffect) 的.fx效果文件
 */

declare class FXParser {
    private options;
    private hlslConverter;
    constructor(options?: FXParserOptions);
    /**
     * 从URL加载并解析FX文件
     */
    loadAndParse(url: string): Promise<FXEffect>;
    /**
     * 解析FX文件内容
     */
    parse(content: string, fileName?: string): FXEffect;
    /**
     * 转换shader到GLSL
     */
    private convertShadersToGLSL;
    /**
     * 解析宏定义 (#define)
     */
    private parseDefines;
    /**
     * 解析参数声明
     */
    private parseParameters;
    /**
     * 解析注解 (annotations)
     */
    private parseAnnotations;
    /**
     * 解析静态变量
     */
    private parseStaticVariables;
    /**
     * 解析纹理引用
     */
    private parseTextures;
    /**
     * 解析控制器引用 (CONTROLOBJECT)
     */
    private parseControllers;
    /**
     * 解析include指令
     */
    private parseIncludes;
    /**
     * 解析Technique定义
     */
    private parseTechniques;
    /**
     * 解析Pass定义
     */
    private parsePasses;
    /**
     * 解析着色器函数
     */
    private parseShaderFunctions;
    /**
     * 解析注释
     */
    private parseComments;
    /**
     * 生成FX文件摘要
     */
    generateSummary(effect: FXEffect): FXSummary;
    /**
     * 提取特定着色器函数的代码
     */
    extractShaderFunction(effect: FXEffect, functionName: string): string | null;
    /**
     * 获取所有启用的功能标志
     */
    getEnabledFeatures(effect: FXEffect): string[];
    /**
     * 获取配置参数
     */
    getConfigParameters(effect: FXEffect): FXParameter[];
}

/**
 * FX到Three.js适配器
 * 将解析的FX文件参数应用到Three.js渲染中
 */

/**
 * Three.js材质配置
 */
interface ThreeMaterialConfig {
    /** 基础颜色 */
    color?: THREE.Color;
    /** 发光颜色 */
    emissive?: THREE.Color;
    /** 高光颜色 */
    specular?: THREE.Color;
    /** 光泽度 */
    shininess?: number;
    /** 透明度 */
    opacity?: number;
    /** 是否透明 */
    transparent?: boolean;
    /** 纹理贴图 */
    map?: THREE.Texture | null;
    /** 法线贴图 */
    normalMap?: THREE.Texture | null;
    /** 环境贴图 */
    envMap?: THREE.Texture | null;
    /** 自定义uniforms */
    uniforms?: Record<string, {
        value: any;
    }>;
}
/**
 * Three.js渲染配置
 */
interface ThreeRenderConfig {
    /** 是否启用阴影 */
    enableShadow?: boolean;
    /** 阴影贴图尺寸 */
    shadowMapSize?: number;
    /** 环境光强度 */
    ambientLightIntensity?: number;
    /** 方向光强度 */
    directionalLightIntensity?: number;
    /** 方向光方向 */
    lightDirection?: THREE.Vector3;
    /** 色调映射 */
    toneMapping?: THREE.ToneMapping;
    /** 曝光度 */
    toneMappingExposure?: number;
}
/**
 * FX到Three.js适配器
 */
declare class FXToThreeAdapter {
    private effect;
    private textureLoader;
    private loadedTextures;
    private basePath;
    constructor(effect: FXEffect, basePath?: string);
    /**
     * 创建ShaderMaterial（如果有GLSL shader）
     */
    createShaderMaterial(): THREE.ShaderMaterial | null;
    /**
     * 获取uniform的默认值
     */
    private getDefaultUniformValue;
    /**
     * 提取材质配置
     */
    extractMaterialConfig(): ThreeMaterialConfig;
    /**
     * 提取渲染配置
     */
    extractRenderConfig(): ThreeRenderConfig;
    /**
     * 加载纹理
     */
    loadTextures(): Promise<Map<string, THREE.Texture>>;
    /**
     * 加载单个纹理
     */
    private loadTexture;
    /**
     * 创建Three.js材质
     */
    createMaterial(): THREE.MeshPhongMaterial;
    /**
     * 配置Three.js场景
     * 仅应用渲染器配置，不添加光源
     */
    configureScene(scene: THREE.Scene, renderer: THREE.WebGLRenderer): void;
    /**
     * 获取指定用途的纹理
     */
    private getTextureByPurpose;
    /**
     * 解析float3值
     */
    private parseFloat3;
    /**
     * 解析float值
     */
    private parseFloat;
    /**
     * 解析参数值
     */
    private parseParameterValue;
    /**
     * 获取所有自定义uniforms
     */
    getUniforms(): Record<string, {
        value: any;
    }>;
    /**
     * 生成配置摘要
     */
    getSummary(): {
        materialParams: string[];
        textures: string[];
        renderFeatures: string[];
    };
}

/**
 * HLSL到GLSL转换器
 * 将MME的HLSL shader代码转换为Three.js可用的GLSL代码
 */
interface ConversionResult {
    /** 转换后的GLSL代码 */
    glslCode: string;
    /** 检测到的uniforms */
    uniforms: Map<string, UniformInfo>;
    /** 检测到的attributes */
    attributes: Map<string, AttributeInfo>;
    /** 检测到的varyings */
    varyings: Map<string, VaryingInfo>;
    /** 转换警告 */
    warnings: string[];
}
interface UniformInfo {
    type: string;
    glslType: string;
    semantic?: string;
}
interface AttributeInfo {
    type: string;
    glslType: string;
    semantic: string;
}
interface VaryingInfo {
    type: string;
    glslType: string;
}
declare class HLSLToGLSLConverter {
    private warnings;
    private uniforms;
    private attributes;
    private varyings;
    /**
     * HLSL类型到GLSL类型的映射
     */
    private typeMap;
    /**
     * HLSL函数到GLSL函数的映射
     */
    private functionMap;
    /**
     * HLSL语义到GLSL的映射
     */
    private semanticMap;
    /**
     * 转换HLSL shader代码为GLSL
     */
    convert(hlslCode: string, shaderType: 'vertex' | 'fragment'): ConversionResult;
    /**
     * 预处理代码
     */
    private preprocessCode;
    /**
     * 转换类型声明
     */
    private convertTypes;
    /**
     * 转换函数调用
     */
    private convertFunctions;
    /**
     * 转换mul()函数
     * HLSL: mul(matrix, vector) 或 mul(vector, matrix)
     * GLSL: matrix * vector 或 vector * matrix
     */
    private convertMulFunction;
    /**
     * 转换语义
     */
    private convertSemantics;
    /**
     * 转换输入/输出结构
     */
    private convertIOStructs;
    /**
     * 解析结构体成员
     */
    private parseStructMembers;
    /**
     * 添加GLSL头部和辅助函数
     */
    private addGLSLHeader;
    /**
     * 修复语法差异
     */
    private fixSyntaxDifferences;
    /**
     * 从FX效果中提取并转换shader
     */
    convertFromFXEffect(effect: any, vertexShaderName: string, fragmentShaderName: string): {
        vertexShader: ConversionResult;
        fragmentShader: ConversionResult;
    } | null;
}

/**
 * 多FX文件适配器
 * 支持同时应用多个FX效果文件
 */

/**
 * 效果文件类型
 */
type EffectFileType = 'fx' | 'x' | 'auto';
/**
 * FX文件配置
 */
interface FXFileConfig {
    /** FX/X文件路径 */
    path: string;
    /** 纹理基础路径 */
    texturePath?: string;
    /** 文件类型 */
    type?: EffectFileType;
    /**
     * 优先级 (数字越大优先级越高，默认0)
     * - .x文件建议设置为低优先级（如-10），作为基础效果
     * - .fx文件建议设置为高优先级（如10），作为细节效果
     */
    priority?: number;
    /**
     * 应用目标
     * - 'all': 应用到所有对象
     * - 'model': 仅应用到模型
     * - 'stage': 仅应用到舞台
     * - 'scene': 仅应用场景配置（光照、阴影等）
     * - string[]: 应用到指定名称的对象
     */
    target?: 'all' | 'model' | 'stage' | 'scene' | string[];
    /** 是否启用 */
    enabled?: boolean;
    /** 描述（用于调试） */
    description?: string;
    /** 是否转换为GLSL并使用ShaderMaterial */
    useShaderMaterial?: boolean;
    /** 顶点着色器函数名（用于GLSL转换） */
    vertexShaderFunction?: string;
    /** 片段着色器函数名（用于GLSL转换） */
    fragmentShaderFunction?: string;
}
/**
 * 多FX合并策略
 */
type FXMergeStrategy = 'override' | 'merge' | 'additive';
/**
 * 多FX适配器配置
 */
interface MultiFXAdapterOptions {
    /** 合并策略 */
    mergeStrategy?: FXMergeStrategy;
    /** 是否自动加载纹理 */
    autoLoadTextures?: boolean;
}
/**
 * 多FX文件适配器
 * 支持同时加载和应用多个FX效果文件
 */
declare class MultiFXAdapter {
    private effects;
    private adapters;
    private configs;
    private options;
    private parser;
    constructor(options?: MultiFXAdapterOptions);
    /**
     * 识别文件类型
     */
    private detectFileType;
    /**
     * 添加效果文件（支持.fx和.x）
     */
    addFX(config: FXFileConfig): Promise<void>;
    /**
     * 批量添加FX文件
     */
    addMultipleFX(configs: FXFileConfig[]): Promise<void>;
    /**
     * 移除FX文件
     */
    removeFX(path: string): void;
    /**
     * 清空所有FX
     */
    clear(): void;
    /**
     * 合并材质配置
     */
    extractMergedMaterialConfig(target?: string): ThreeMaterialConfig;
    /**
     * 合并渲染配置
     */
    extractMergedRenderConfig(): ThreeRenderConfig;
    /**
     * 应用到Three.js材质
     * 支持MeshPhongMaterial和MeshToonMaterial（MMD常用）
     */
    applyToMaterial(material: THREE.Material, target?: string): void;
    /**
     * 创建ShaderMaterial（如果配置了useShaderMaterial）
     * 返回第一个匹配target的ShaderMaterial，如果没有则返回null
     */
    createShaderMaterial(target?: string): THREE.ShaderMaterial | null;
    /**
     * 应用到Three.js场景
     */
    applyToScene(scene: THREE.Scene, renderer: THREE.WebGLRenderer): void;
    /**
     * 获取所有已加载的FX效果
     */
    getLoadedEffects(): FXEffect[];
    /**
     * 获取配置摘要
     */
    getSummary(): {
        totalFX: number;
        enabledFX: number;
        xFiles: number;
        fxFiles: number;
        configs: Array<{
            path: string;
            type: EffectFileType;
            priority: number;
            target: string | string[];
            features: string[];
            description?: string;
        }>;
    };
    /**
     * 获取指定类型的配置
     */
    getConfigsByType(type: EffectFileType): FXFileConfig[];
    /**
     * 获取场景级效果（.x文件）
     */
    getSceneEffects(): FXFileConfig[];
    /**
     * 获取模型级效果（.fx文件）
     */
    getModelEffects(): FXFileConfig[];
    /**
     * 获取合并后的Uniforms
     */
    getMergedUniforms(target?: string): Record<string, {
        value: any;
    }>;
    /**
     * 分层应用到场景对象
     * @param scene Three.js场景
     * @param renderer Three.js渲染器
     * @param modelMeshes 模型网格数组（可选，用于精确控制）
     * @param stageMeshes 舞台网格数组（可选，用于精确控制）
     */
    applyLayered(scene: THREE.Scene, renderer: THREE.WebGLRenderer, modelMeshes?: THREE.Object3D[], stageMeshes?: THREE.Object3D[]): void;
    /**
     * 打印当前配置（调试用）
     */
    printConfig(): void;
}

/**
 * FX解析器工具函数
 */

/**
 * 将FX效果导出为JSON
 */
declare function exportFXToJSON(effect: FXEffect): string;
/**
 * 将FX效果导出为Markdown文档
 */
declare function exportFXToMarkdown(effect: FXEffect): string;
/**
 * 比较两个FX文件的差异
 */
declare function compareFXEffects(effect1: FXEffect, effect2: FXEffect): {
    addedDefines: string[];
    removedDefines: string[];
    changedDefines: {
        name: string;
        oldValue?: string;
        newValue?: string;
    }[];
    addedTextures: string[];
    removedTextures: string[];
    addedParameters: string[];
    removedParameters: string[];
};
/**
 * 过滤特定类型的宏定义
 */
declare function filterDefinesByPrefix(defines: FXDefine[], prefix: string): FXDefine[];
/**
 * 获取所有纹理宏定义
 */
declare function getTextureDefines(defines: FXDefine[]): FXDefine[];
/**
 * 获取所有功能标志
 */
declare function getFeatureFlags(defines: FXDefine[]): FXDefine[];
/**
 * 获取所有颜色相关的参数
 */
declare function getColorParameters(parameters: FXParameter[]): FXParameter[];
/**
 * 检查是否包含特定功能
 */
declare function hasFeature(effect: FXEffect, featureName: string): boolean;
/**
 * 获取配置摘要文本
 */
declare function getConfigSummaryText(effect: FXEffect): string;
/**
 * 提取纹理文件路径列表（用于预加载）
 */
declare function extractTexturePaths(effect: FXEffect): string[];
/**
 * 验证FX文件的完整性
 */
declare function validateFXEffect(effect: FXEffect): {
    isValid: boolean;
    errors: string[];
    warnings: string[];
};

/**
 * FX文件查看器组件
 * 用于可视化展示FX文件的解析结果
 */

interface FXViewerProps {
    /** FX文件URL或内容 */
    source: string;
    /** 是否是文件内容（true）还是URL（false） */
    isContent?: boolean;
    /** 文件名 */
    fileName?: string;
    /** 解析完成回调 */
    onParsed?: (effect: FXEffect) => void;
    /** 错误回调 */
    onError?: (error: Error) => void;
    /** 自定义样式 */
    className?: string;
}
declare const FXViewer: React__default.FC<FXViewerProps>;

/**
 * FX效果Three.js预览组件
 * 展示如何将FX解析结果应用到Three.js渲染中
 */

interface FXThreePreviewProps {
    /** FX效果 */
    effect: FXEffect;
    /** 纹理基础路径 */
    texturePath?: string;
    /** 预览对象类型 */
    objectType?: 'sphere' | 'box' | 'torus' | 'plane';
    /** 自定义样式 */
    className?: string;
    /** 是否显示信息面板 */
    showInfo?: boolean;
}
declare const FXThreePreview: React__default.FC<FXThreePreviewProps>;

export { ARMode, type AudioPreset, type BranchCondition, CheerButton, type CheerButtonProps, CheerParticles, type CheerParticlesProps, type CheerParticlesRef, ChoiceMenu, type ChoiceMenuProps, DialogueBox, type DialogueBoxProps, type DialogueBoxTheme, type DialogueChoice, type DialogueHistoryItem, type DialogueLine, type EffectFileType, type FXComment, type FXController, type FXDefine, type FXEffect, type FXFileConfig, type FXMergeStrategy, type FXParameter, FXParser, type FXParserOptions, type FXPass, type FXShaderFunction, type FXStaticVariable, type FXSummary, type FXTechnique, type FXTexture, FXThreePreview, type FXThreePreviewProps, FXToThreeAdapter, FXViewer, type FXViewerProps, type GLSLShader, type GLSLShaders, HLSLToGLSLConverter, HistoryPanel, LoadingOverlay, type LoadingOverlayProps, LoadingScreen, type LoadingScreenProps, LoopConfirmDialog, MMDARPlayer, type MMDARPlayerProps, type MMDARPlayerRef, type MMDDiagnosticReport, MMDLightingDebugPanel, type MMDLightingDebugPanelProps, type MMDLightingParams, type MMDLoaderConfig, MMDMusicPlayer, type MMDMusicPlayerConfig, type MMDMusicPlayerProps, type MMDMusicPlayerRef, MMDPlayerBase, MMDPlayerBaseProps, MMDPlayerBaseRef, MMDPlayerEnhanced, MMDPlayerEnhancedDebugInfo, MMDPlayerEnhancedProps, MMDPlaylist, MMDPlaylistDebugInfo, MMDPlaylistNode, MMDPlaylistProps, MMDResources, type MMDSceneRefs, MMDStage, MMDVisualNovel, type MMDVisualNovelProps, type MMDVisualNovelRef, MMDVisualNovelWithSelector, type MMDVisualNovelWithSelectorProps, type MMDVisualNovelWithSelectorRef, type MaterialTextureMapping, MobileOptimization, type ModelOption, type ModelPreset, type ModelSelectorConfig, ModelSelectorSettings, type ModelSelectorSettingsProps, type MotionPreset, MultiFXAdapter, type MultiFXAdapterOptions, MusicControls, type MusicControlsProps, type MusicTrack, PMXEditor, PMXEditor$1 as PMXEditorCore, type PMXEditorProps, PMXExporter, type PMXHeader, type PMXMaterial, type PMXModelInfo, type PMXParseResult, PMXParser, type PMXTexture, type PMXVertex, PMXViewer, type PMXViewerProps, PlaylistPanel, type PlaylistPanelProps, type SphereTextureDiagnostic, StartScreen, type StartScreenProps, type ThreeMaterialConfig, type ThreeRenderConfig, TrackInfo, type TrackInfoProps, type VisualEffect, type VisualNovelNode, type VisualNovelScript, addDefaultSphereTextures, checkModelSphereDefinition, checkSphereTextures, compareFXEffects, configureMaterialsForMMD, configureRendererForMMD, createMMDLights, diagnoseMaterialsMMD, exportFXToJSON, exportFXToMarkdown, extractTexturePaths, filterDefinesByPrefix, fullSphereDiagnostic, generateAllToonTextures, generateToonTexture, getColorParameters, getConfigSummaryText, getFeatureFlags, getTextureDefines, hasFeature, inspectMaterial, listAllMaterials, loadAmmo, printDiagnosticReport, printModelSphereInfo, printSphereDiagnostic, quickDiagnose, validateFXEffect };
