Update Shader and UniformsUtils

types/three/src/renderers/shaders/ShaderLib.d.ts

@@ -1,9 +1,8 @@
+import { WebGLProgramParameters } from '../webgl/WebGLProgramParameters.js';
 import { IUniform } from './UniformsLib.js';
 
-export interface Shader {
+export interface Shader extends WebGLProgramParameters {
     uniforms: { [uniform: string]: IUniform };
-    vertexShader: string;
-    fragmentShader: string;
 }
 
 export let ShaderLib: {

types/three/src/renderers/shaders/UniformsUtils.d.ts

@@ -1,7 +1,8 @@
 import { UniformsGroup } from '../../core/UniformsGroup.js';
+import { IUniform } from './UniformsLib.js';
 
-export function cloneUniforms(uniforms_src: any): any;
-export function mergeUniforms(uniforms: any): any;
+export function cloneUniforms<T extends { [uniform: string]: IUniform }>(uniformsSrc: T): T;
+export function mergeUniforms(uniforms: Array<{ [uniform: string]: IUniform }>): { [uniform: string]: IUniform };
 
 export function cloneUniformsGroups(src: UniformsGroup[]): UniformsGroup[];
 

types/three/src/renderers/webgl/WebGLLights.d.ts

@@ -1,47 +1,49 @@
 import { WebGLExtensions } from './WebGLExtensions.js';
 import { WebGLCapabilities } from './WebGLCapabilities.js';
 
-export class WebGLLights {
-    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+export interface WebGLLightsState {
+    version: number;
+
+    hash: {
+        directionalLength: number;
+        pointLength: number;
+        spotLength: number;
+        rectAreaLength: number;
+        hemiLength: number;
+
+        numDirectionalShadows: number;
+        numPointShadows: number;
+        numSpotShadows: number;
+        numSpotMaps: number;
 
-    state: {
-        version: number;
-
-        hash: {
-            directionalLength: number;
-            pointLength: number;
-            spotLength: number;
-            rectAreaLength: number;
-            hemiLength: number;
-
-            numDirectionalShadows: number;
-            numPointShadows: number;
-            numSpotShadows: number;
-            numSpotMaps: number;
-
-            numLightProbes: number;
-        };
-
-        ambient: number[];
-        probe: any[];
-        directional: any[];
-        directionalShadow: any[];
-        directionalShadowMap: any[];
-        directionalShadowMatrix: any[];
-        spot: any[];
-        spotShadow: any[];
-        spotShadowMap: any[];
-        spotShadowMatrix: any[];
-        rectArea: any[];
-        point: any[];
-        pointShadow: any[];
-        pointShadowMap: any[];
-        pointShadowMatrix: any[];
-        hemi: any[];
-        numSpotLightShadowsWithMaps: number;
         numLightProbes: number;
     };
 
+    ambient: number[];
+    probe: any[];
+    directional: any[];
+    directionalShadow: any[];
+    directionalShadowMap: any[];
+    directionalShadowMatrix: any[];
+    spot: any[];
+    spotShadow: any[];
+    spotShadowMap: any[];
+    spotShadowMatrix: any[];
+    rectArea: any[];
+    point: any[];
+    pointShadow: any[];
+    pointShadowMap: any[];
+    pointShadowMatrix: any[];
+    hemi: any[];
+    numSpotLightShadowsWithMaps: number;
+    numLightProbes: number;
+}
+
+export class WebGLLights {
+    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+
+    state: WebGLLightsState;
+
     get(light: any): any;
     setup(lights: any): void;
     setupView(lights: any, camera: any): void;

types/three/src/renderers/webgl/WebGLProgramParameters.d.ts

@@ -0,0 +1,199 @@
+import {
+    ColorSpace,
+    Combine,
+    DepthPackingStrategies,
+    GLSLVersion,
+    ShadowMapType,
+    ToneMapping,
+} from '../../constants.js';
+
+export interface WebGLProgramParameters {
+    isWebGL2: boolean;
+
+    shaderID: string;
+    shaderType: string;
+    shaderName: string;
+
+    vertexShader: string;
+    fragmentShader: string;
+    defines?: { [define: string]: string | number | boolean };
+
+    customVertexShaderID?: string;
+    customFragmentShaderID?: string;
+
+    isRawShaderMaterial: boolean;
+    glslVersion?: GLSLVersion;
+
+    precision: 'lowp' | 'mediump' | 'highp';
+
+    batching: boolean;
+    instancing: boolean;
+    instancingColor: boolean;
+
+    supportsVertexTextures: boolean;
+    outputColorSpace: ColorSpace;
+
+    map: boolean;
+    matcap: boolean;
+    envMap: boolean;
+    envMapMode: boolean;
+    envMapCubeUVHeight: number | null;
+    aoMap: boolean;
+    lightMap: boolean;
+    bumpMap: boolean;
+    normalMap: boolean;
+    displacementMap: boolean;
+    emissiveMap: boolean;
+
+    normalMapObjectSpace: boolean;
+    normalMapTangentSpace: boolean;
+
+    metalnessMap: boolean;
+    roughnessMap: boolean;
+
+    anisotropy: boolean;
+    anisotropyMap: boolean;
+
+    clearcoat: boolean;
+    clearcoatMap: boolean;
+    clearcoatNormalMap: boolean;
+    clearcoatRoughnessMap: boolean;
+
+    iridescence: boolean;
+    iridescenceMap: boolean;
+    iridescenceThicknessMap: boolean;
+
+    sheen: boolean;
+    sheenColorMap: boolean;
+    sheenRoughnessMap: boolean;
+
+    specularMap: boolean;
+    specularColorMap: boolean;
+    specularIntensityMap: boolean;
+
+    transmission: boolean;
+    transmissionMap: boolean;
+    thicknessMap: boolean;
+
+    gradientMap: boolean;
+
+    opaque: boolean;
+
+    alphaMap: boolean;
+    alphaTest: boolean;
+    alphaHash: boolean;
+
+    combine: Combine;
+
+    //
+
+    mapUv: boolean;
+    aoMapUv: boolean;
+    lightMapUv: boolean;
+    bumpMapUv: boolean;
+    normalMapUv: boolean;
+    displacementMapUv: boolean;
+    emissiveMapUv: boolean;
+
+    metalnessMapUv: boolean;
+    roughnessMapUv: boolean;
+
+    anisotropyMapUv: boolean;
+
+    clearcoatMapUv: boolean;
+    clearcoatNormalMapUv: boolean;
+    clearcoatRoughnessMapUv: boolean;
+
+    iridescenceMapUv: boolean;
+    iridescenceThicknessMapUv: boolean;
+
+    sheenColorMapUv: boolean;
+    sheenRoughnessMapUv: boolean;
+
+    specularMapUv: boolean;
+    specularColorMapUv: boolean;
+    specularIntensityMapUv: boolean;
+
+    transmissionMapUv: boolean;
+    thicknessMapUv: boolean;
+
+    alphaMapUv: boolean;
+
+    //
+
+    vertexTangents: boolean;
+    vertexColors: boolean;
+    vertexAlphas: boolean;
+    vertexUv1s: boolean;
+    vertexUv2s: boolean;
+    vertexUv3s: boolean;
+
+    pointsUvs: boolean;
+
+    fog: boolean;
+    useFog: boolean;
+    fogExp2: boolean | null; // null is possible because of a bug: ( fog && fog.isFogExp2 )
+
+    flatShading: boolean;
+
+    sizeAttenuation: boolean;
+    logarithmicDepthBuffer: boolean;
+
+    skinning: boolean;
+
+    morphTargets: boolean;
+    morphNormals: boolean;
+    morphColors: boolean;
+    morphTargetsCount: number;
+    morphTextureStride: number;
+
+    numDirLights: number;
+    numPointLights: number;
+    numSpotLights: number;
+    numSpotLightMaps: number;
+    numRectAreaLights: number;
+    numHemiLights: number;
+
+    numDirLightShadows: number;
+    numPointLightShadows: number;
+    numSpotLightShadows: number;
+    numSpotLightShadowsWithMaps: number;
+
+    numLightProbes: number;
+
+    numClippingPlanes: number;
+    numClipIntersection: number;
+
+    dithering: boolean;
+
+    shadowMapEnabled: boolean;
+    shadowMapType: ShadowMapType;
+
+    toneMapping: ToneMapping;
+    useLegacyLights: boolean;
+
+    decodeVideoTexture: boolean;
+
+    premultipliedAlpha: boolean;
+
+    doubleSided: boolean;
+    flipSided: boolean;
+
+    useDepthPacking: boolean;
+    depthPacking: DepthPackingStrategies;
+
+    index0AttributeName: string;
+
+    extensionDerivatives: boolean;
+    extensionFragDepth: boolean;
+    extensionDrawBuffers: boolean;
+    extensionShaderTextureLOD: boolean;
+    extensionClipCullDistance: boolean;
+
+    rendererExtensionFragDepth: boolean;
+    rendererExtensionDrawBuffers: boolean;
+    rendererExtensionShaderTextureLod: boolean;
+    rendererExtensionParallelShaderCompile: boolean;
+
+    customProgramCacheKey: string;
+}

types/three/src/renderers/webgl/WebGLPrograms.d.ts

@@ -1,12 +1,17 @@
+import { Material } from '../../materials/Material.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Light } from '../../lights/Light.js';
+import { Scene } from '../../scenes/Scene.js';
+import { IUniform } from '../shaders/UniformsLib.js';
 import { WebGLRenderer } from '../WebGLRenderer.js';
-import { WebGLProgram } from './WebGLProgram.js';
+import { WebGLBindingStates } from './WebGLBindingStates.js';
 import { WebGLCapabilities } from './WebGLCapabilities.js';
+import { WebGLClipping } from './WebGLClipping.js';
 import { WebGLCubeMaps } from './WebGLCubeMaps.js';
 import { WebGLExtensions } from './WebGLExtensions.js';
-import { WebGLClipping } from './WebGLClipping.js';
-import { WebGLBindingStates } from './WebGLBindingStates.js';
-import { Material } from '../../materials/Material.js';
-import { Scene } from '../../scenes/Scene.js';
+import { WebGLLightsState } from './WebGLLights.js';
+import { WebGLProgram } from './WebGLProgram.js';
+import { WebGLProgramParameters } from './WebGLProgramParameters.js';
 
 export class WebGLPrograms {
     constructor(
@@ -20,9 +25,16 @@ export class WebGLPrograms {
 
     programs: WebGLProgram[];
 
-    getParameters(material: Material, lights: any, shadows: object[], scene: Scene, object: any): any;
-    getProgramCacheKey(parameters: any): string;
-    getUniforms(material: Material): object;
-    acquireProgram(parameters: any, cacheKey: string): WebGLProgram;
+    getParameters(
+        material: Material,
+        lights: WebGLLightsState,
+        shadows: Light[],
+        scene: Scene,
+        object: Object3D,
+    ): WebGLProgramParameters;
+
+    getProgramCacheKey(parameters: WebGLProgramParameters): string;
+    getUniforms(material: Material): { [uniform: string]: IUniform };
+    acquireProgram(parameters: WebGLProgramParameters, cacheKey: string): WebGLProgram;
     releaseProgram(program: WebGLProgram): void;
 }