import { spec, Geometry } from '@galacean/effects';
import type { TextureSourceOptions, math, Engine, Texture } from '@galacean/effects';
import type { SkyboxType, LoadSceneOptions, LoadSceneResult, Loader, ModelCamera, ModelLight, ModelImageLike } from './protocol';
import type { ModelMeshComponentData, ModelSkyboxComponentData, ModelLightComponentData, ModelCameraComponentData, ModelAnimationOptions, ModelMaterialOptions, ModelSkyboxOptions } from '../index';
import { PSkyboxType } from '../runtime';
import type { PSkyboxURLParams } from '../runtime/skybox';
import type { GLTFImage, GLTFMaterial, GLTFTexture, GLTFLight, GLTFCamera, GLTFAnimation, GLTFResources, GLTFImageBasedLight, GLTFPrimitive } from '@vvfx/resource-detection';
import type { CubeImage } from '@vvfx/resource-detection/dist/src/gltf-tools/gltf-image-based-light';
export interface LoaderOptions {
    compatibleMode?: 'gltf' | 'tiny3d';
}
export declare function getDefaultEffectsGLTFLoader(engine: Engine, options?: LoaderOptions): Loader;
export declare function setDefaultEffectsGLTFLoader(loader: Loader): void;
export declare class LoaderImpl implements Loader {
    private sceneOptions;
    private loaderOptions;
    private gltfMeshs;
    private gltfTextures;
    private gltfMaterials;
    private gltfAnimations;
    private gltfImageBasedLights;
    composition: spec.CompositionData;
    timelineAssetId: string;
    images: spec.Image[];
    imageElements: ModelImageLike[];
    textures: spec.TextureDefine[];
    items: spec.VFXItemData[];
    components: spec.ComponentData[];
    materials: spec.MaterialData[];
    shaders: spec.ShaderData[];
    geometries: spec.GeometryData[];
    animations: spec.AnimationClipData[];
    sceneAABB: math.Box3;
    engine: Engine;
    constructor(composition?: spec.CompositionData);
    loadScene(options: LoadSceneOptions): Promise<LoadSceneResult>;
    processGLTFResource(resource: GLTFResources, imageElements: ModelImageLike[]): void;
    processComponentData(components: spec.EffectComponentData[]): void;
    processLightComponentData(light: ModelLightComponentData): void;
    processCameraComponentData(camera: ModelCameraComponentData): void;
    processSkyboxComponentData(skybox: ModelSkyboxComponentData): void;
    processMaterialData(material: spec.MaterialData): void;
    processTextureOptions(options: TextureSourceOptions, isBaseColor: boolean, image?: ModelImageLike): void;
    initial(engine: Engine, options?: LoaderOptions): void;
    checkMeshComponentData(mesh: ModelMeshComponentData, resource: GLTFResources): void;
    processMaterialTexture(material: spec.MaterialData, textureName: string, isBaseColor: boolean, textureDataMap: Record<string, TextureSourceOptions>, imageElements: ModelImageLike[]): void;
    getLoadResult(): LoadSceneResult;
    addLight(data: ModelLight): void;
    addCamera(camera: ModelCamera): void;
    addSkybox(skybox: PSkyboxURLParams): void;
    private tryAddSkybox;
    createSkyboxComponentData(typeName: SkyboxType): {
        imageList: spec.Image[];
        textureOptionsList: TextureSourceOptions[];
        component: spec.SkyboxComponentData;
    };
    dispose(): void;
    clear(): void;
    private computeSceneAABB;
    isPlayAnimation(): boolean;
    isPlayAllAnimation(): boolean;
    getRemarkString(): string;
    getCompositionDuration(): number;
    isTiny3dMode(): boolean;
    getItemDuration(): number;
    getEndBehavior(): spec.EndBehavior;
    getSkyboxType(): PSkyboxType | undefined;
    isSkyboxVis(): boolean;
    ignoreSkybox(): boolean;
    isEnvironmentTest(): boolean;
    /**
     * for old scene compatibility
     */
    processLight(lights: GLTFLight[], fromGLTF: boolean): void;
    processCamera(cameras: GLTFCamera[], fromGLTF: boolean): void;
    processMaterial(materials: GLTFMaterial[], fromGLTF: boolean): void;
    createAnimations(animations: GLTFAnimation[]): ModelAnimationOptions[];
    createGeometry(primitive: GLTFPrimitive, hasSkinAnim: boolean): Geometry;
    createMaterial(material: GLTFMaterial): ModelMaterialOptions;
    createTexture2D(image: GLTFImage, texture: GLTFTexture, isBaseColor: boolean): Promise<Texture>;
    createTextureCube(cubeImages: CubeImage[], level0Size?: number): Promise<Texture>;
    createSkybox(ibl: GLTFImageBasedLight): Promise<ModelSkyboxOptions>;
    createDefaultSkybox(typeName: SkyboxType): Promise<ModelSkyboxOptions>;
    scaleColorVal(val: number, fromGLTF: boolean): number;
    scaleColorVec(vec: number[], fromGLTF: boolean): number[];
}
export declare function getPBRShaderProperties(): string;
export declare function getUnlitShaderProperties(): string;
export declare function getDefaultPBRMaterialData(): spec.MaterialData;
export declare function getDefaultUnlitMaterialData(): spec.MaterialData;
