import { GeometryData, MaterialBasicLineData, MaterialPointData, MaterialStandardData } from "@shapediver/viewer.shared.node-tree";
import { type IMaterialAbstractData, MATERIAL_TYPE, PRIMITIVE_MODE } from "@shapediver/viewer.shared.types";
import { quat } from "gl-matrix";
import * as THREE from "three";
import { type ILoader } from "../interfaces/ILoader";
import { type GemMaterialParameters } from "../materials/GemMaterial";
import { type MeshUnlitMaterialParameters } from "../materials/MeshUnlitMaterialParameters";
import { MultiPointsMaterial, type MultiPointsMaterialParameters } from "../materials/MultiPointsMaterial";
import { type SpecularGlossinessMaterialParameters } from "../materials/SpecularGlossinessMaterial";
import { RenderingEngine } from "../RenderingEngine";
import { ENVIRONMENT_MAP_TYPE } from "./EnvironmentMapLoader";
export type MaterialSettings = {
    mode: PRIMITIVE_MODE;
    useVertexTangents: boolean;
    useVertexColors: boolean;
    useFlatShading: boolean;
    useMorphTargets: boolean;
    useMorphNormals: boolean;
};
type ThreeJsMaterialParameterTypes = THREE.PointsMaterialParameters | MultiPointsMaterialParameters | THREE.LineBasicMaterialParameters | MeshUnlitMaterialParameters | THREE.MeshPhysicalMaterialParameters | SpecularGlossinessMaterialParameters | GemMaterialParameters | THREE.ShadowMaterialParameters | THREE.MeshLambertMaterialParameters | THREE.MeshPhongMaterialParameters;
type ThreeJsTextureCacheObject = {
    texture: THREE.Texture;
    usage: number;
    initialized: boolean;
};
export declare class MaterialLoader implements ILoader {
    private readonly _renderingEngine;
    private readonly _converter;
    private readonly _sceneTree;
    private _blending;
    private _defaultLineMaterialData;
    private _defaultMaterialData;
    private _defaultPointMaterialData;
    private _envMap;
    private _envMapIntensity;
    private _envMapType;
    private _environmentMapRotationEuler;
    private _height;
    private _lightSizeUV;
    private _materialOverrideType;
    private _materialCache;
    private _shaderProgramCache;
    private _compiledShaderSignatures;
    private _maxMapCount;
    private _pointSize;
    private _textureEncoding;
    private _threeJsTextureCache;
    constructor(_renderingEngine: RenderingEngine);
    get defaultLineMaterialData(): MaterialBasicLineData;
    set defaultLineMaterialData(value: MaterialBasicLineData);
    get defaultMaterialData(): MaterialStandardData;
    set defaultMaterialData(value: MaterialStandardData);
    get defaultPointMaterialData(): MaterialPointData;
    set defaultPointMaterialData(value: MaterialPointData);
    get materialOverrideType(): MATERIAL_TYPE | undefined;
    set materialOverrideType(value: MATERIAL_TYPE | undefined);
    get maxMapCount(): number;
    set maxMapCount(value: number);
    get textureEncoding(): THREE.ColorSpace;
    set textureEncoding(value: THREE.ColorSpace);
    get threeJsTextureCache(): {
        [key: string]: ThreeJsTextureCacheObject;
    };
    set threeJsTextureCache(value: {
        [key: string]: ThreeJsTextureCacheObject;
    });
    assignColorCorrection(value: boolean): void;
    assignDefaultLineMaterial(): void;
    assignDefaultMaterial(): void;
    assignDefaultPointMaterial(): void;
    assignEnvironmentMap(e: THREE.CubeTexture | THREE.Texture | null, type: ENVIRONMENT_MAP_TYPE): void;
    assignEnvironmentMapForUnlitMaterials(toggle: boolean): void;
    assignEnvironmentMapIntensity(value: number): void;
    assignEnvironmentMapRotation(value: quat): void;
    assignPointSize(p: number): void;
    cacheSize(): number;
    createMaterial(type: GEOMETRY_MATERIAL_TYPE, incomingData: IMaterialAbstractData | GeometryData, materialData: IMaterialAbstractData | null, materialSettings?: MaterialSettings): THREE.Material | MultiPointsMaterial | THREE.PointsMaterial | THREE.MeshBasicMaterial | THREE.LineBasicMaterial;
    emptyMaterialCache(): void;
    getMaterialProperties(materialData: IMaterialAbstractData | null, type: GEOMETRY_MATERIAL_TYPE, materialSettings?: MaterialSettings): {
        properties: ThreeJsMaterialParameterTypes;
        mapCount: number;
    };
    init(): void;
    /**
     * Get a shader signature based on properties that affect shader compilation.
     * Materials with the same signature can share compiled shader programs.
     */
    private getShaderSignature;
    /**
     * Precompile shaders for a batch of materials to avoid runtime compilation costs.
     * This should be called during initialization or loading phases.
     */
    precompileShaders(materials: THREE.Material[], scene: THREE.Scene, camera: THREE.Camera): void;
    /**
     * Create a material object with the provided material data.
     *
     * @param material the material data
     * @returns the material object
     */
    load(incomingData: IMaterialAbstractData | GeometryData, materialSettings?: MaterialSettings): THREE.Material;
    removeFromMaterialCache(cacheKey: string): void;
    updateMaterials(): void;
    updateSoftShadow(lightSizeUV: number, blending: number): void;
    private assignTextureEncoding;
    private createDataKeyFromMap;
    private createDataKeyFromMaterial;
    private createTexture;
}
declare enum GEOMETRY_MATERIAL_TYPE {
    POINT = "point",
    LINE = "line",
    MESH = "mesh"
}
export declare const adaptShaders: () => void;
export {};
//# sourceMappingURL=MaterialLoader.d.ts.map