@roomle/web-sdk 2.60.0-alpha.2 → 2.60.0-alpha.3

package/lib/definitions/common-core/src/webgl/renderer/light-source-detection.d.ts

@@ -0,0 +1,76 @@
+import { OrthographicCamera, ShaderMaterial, Texture, Vector2, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare const sphereToEquirectangular: (pointOnSphere: Vector3) => Vector2;
+export declare const equirectangularToSphere: (uv: Vector2) => Vector3;
+export interface TextureConverterResult {
+    texture: Texture;
+    pixels: Uint8Array;
+}
+export declare class TextureConverter {
+    private _colorRenderTarget?;
+    private _grayscaleRenderTarget?;
+    private _grayscaleShaderMaterial?;
+    private _camera?;
+    private planeMesh?;
+    get colorRenderTarget(): WebGLRenderTarget;
+    get grayscaleRenderTarget(): WebGLRenderTarget;
+    get grayscaleShaderMaterial(): GrayscaleShaderMaterial;
+    get camera(): OrthographicCamera;
+    scaleTexture(renderer: WebGLRenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
+    newGrayscaleTexture(renderer: WebGLRenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
+}
+export declare class GrayscaleShaderMaterial extends ShaderMaterial {
+    constructor();
+    setSourceTexture(map: Texture): void;
+}
+export declare class LightSourceDetector {
+    private numberOfSamples;
+    private width;
+    private height;
+    private sampleThreshold;
+    readonly pointDistance: number;
+    readonly pixelDistance: number;
+    readonly samplePoints: Vector3[];
+    readonly sampleUVs: Vector2[];
+    textureData?: any;
+    grayscaleTexture: TextureConverterResult;
+    detectorTexture: Texture;
+    detectorArray: Float32Array;
+    private textureConverter?;
+    lightSamples: LightSample[];
+    lightGraph: LightGraph;
+    lightSources: LightSource[];
+    constructor(parameters?: any);
+    detectLightSources(renderer: WebGLRenderer, equirectangularTexture: Texture, textureData?: any): void;
+    private createEquirectangularSamplePoints;
+    private redFromRgbaToNormalizedFloatArray;
+    private grayscaleTextureFromFloatArray;
+    private filterLightSamples;
+    private detectorTextureLuminanceValueFromUV;
+    private originalLuminanceValueFromUV;
+    private findClusterSegments;
+    private createLightSourcesFromLightGraph;
+}
+export declare class LightSample {
+    readonly position: Vector3;
+    readonly uv: Vector2;
+    constructor(position: Vector3, uv: Vector2);
+}
+export declare class LightGraph {
+    readonly noOfNodes: number;
+    edges: number[][];
+    adjacent: number[][];
+    components: number[][];
+    constructor(noOfNodes: number);
+    findConnectedComponents(): void;
+    private dfs;
+}
+export declare class LightSource {
+    readonly lightSamples: LightSample[];
+    position: Vector3;
+    uv: Vector2;
+    averageIntensity: number;
+    maxIntensity: number;
+    size: number;
+    constructor(lightSamples: LightSample[]);
+    calculateLightSourceProperties(luminanceFunction: (uv: Vector2) => number): void;
+}

package/lib/definitions/common-core/src/webgl/renderer/outline-pass.d.ts

@@ -0,0 +1,56 @@
+import { Pass, FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+import { Camera, Color, Matrix4, MeshDepthMaterial, Object3D, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare class OutlinePass extends Pass {
+    static BlurDirectionX: Vector2;
+    static BlurDirectionY: Vector2;
+    private gBufferRenderTarget?;
+    renderScene: Scene;
+    renderCamera: Camera;
+    selectedObjects: Object3D[];
+    visibleEdgeColor: Color;
+    hiddenEdgeColor: Color;
+    edgeGlow: number;
+    usePatternTexture: boolean;
+    patternTexture: Texture | null;
+    edgeThickness: number;
+    edgeStrength: number;
+    downSampleRatio: number;
+    pulsePeriod: number;
+    edgeDetectionFxaa: boolean;
+    _visibilityCache: Map<Object3D, boolean>;
+    resolution: Vector2;
+    renderTargetMaskBuffer: WebGLRenderTarget;
+    depthMaterial?: MeshDepthMaterial;
+    prepareMaskMaterial: ShaderMaterial;
+    renderTargetFxaaBuffer?: WebGLRenderTarget;
+    fxaaRenderMaterial?: ShaderMaterial;
+    renderTargetDepthBuffer?: WebGLRenderTarget;
+    renderTargetMaskDownSampleBuffer: WebGLRenderTarget;
+    renderTargetBlurBuffer1: WebGLRenderTarget;
+    renderTargetBlurBuffer2: WebGLRenderTarget;
+    edgeDetectionMaterial: ShaderMaterial;
+    renderTargetEdgeBuffer1: WebGLRenderTarget;
+    renderTargetEdgeBuffer2: WebGLRenderTarget;
+    separableBlurMaterial1: ShaderMaterial;
+    separableBlurMaterial2: ShaderMaterial;
+    overlayMaterial: ShaderMaterial;
+    copyUniforms: any;
+    materialCopy: ShaderMaterial;
+    _oldClearColor: Color;
+    oldClearAlpha: number;
+    fsQuad: FullScreenQuad;
+    tempPulseColor1: Color;
+    tempPulseColor2: Color;
+    textureMatrix: Matrix4;
+    constructor(resolution: Vector2, scene: Scene, camera: Camera, selectedObjects: Object3D[], parameters?: any);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    changeVisibilityOfSelectedObjects(bVisible: boolean): void;
+    changeVisibilityOfNonSelectedObjects(bVisible: boolean): void;
+    updateTextureMatrix(): void;
+    render(renderer: WebGLRenderer, _writeBuffer: WebGLRenderTarget | null, readBuffer: WebGLRenderTarget | null, _deltaTime: number, maskActive: boolean): void;
+    getPrepareMaskMaterial(floatAlphaDepth?: boolean): ShaderMaterial;
+    getEdgeDetectionMaterial(): ShaderMaterial;
+    getSeperableBlurMaterial(maxRadius: number): ShaderMaterial;
+    getOverlayMaterial(): ShaderMaterial;
+}

package/lib/definitions/common-core/src/webgl/renderer/outline-renderer.d.ts

@@ -0,0 +1,32 @@
+import { OutlinePass } from './outline-pass';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
+import { Camera, Object3D, Scene } from 'three';
+export interface OutlineParameters {
+    [key: string]: any;
+    enabled: boolean;
+    edgeStrength: number;
+    edgeGlow: number;
+    edgeThickness: number;
+    pulsePeriod: number;
+    usePatternTexture: false;
+    visibleEdgeColor: any;
+    hiddenEdgeColor: any;
+}
+export declare class OutLineRenderer {
+    parameters: OutlineParameters;
+    private width;
+    private height;
+    private effectComposer;
+    private gBufferRenderTarget?;
+    outlinePass: OutlinePass | null;
+    outlinePassActivated: boolean;
+    get isOutlinePassActivated(): boolean;
+    constructor(effectComposer: EffectComposer | null, width: number, height: number, parameters: any);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: any): void;
+    applyParameters(): void;
+    activateOutline(scene: Scene, camera: Camera): void;
+    deactivateOutline(): void;
+    updateOutline(scene: Scene, camera: Camera, selectedObjects: Object3D[]): void;
+}

package/lib/definitions/common-core/src/webgl/renderer/render-utility.d.ts

@@ -0,0 +1,83 @@
+import { Box3, Camera, Color, CubeTexture, DataTexture, Material, Object3D, OrthographicCamera, PerspectiveCamera, ShaderMaterialParameters, Scene, Texture, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare const createUniformColorTexture: (color: Color) => Texture;
+export declare const createUniformColorCubeTexture: (color: Color) => CubeTexture;
+export declare const createNoiseTexture: (size: number, min: number, max: number) => Texture;
+export declare const loadAndSetTexture: (setTexture: (texture: Texture) => void, resource: string, color?: Color) => void;
+export declare const setOrthographicViewVolumeFromBox: (camera: OrthographicCamera, viewBox: Box3) => void;
+export declare const setPerspectiveViewVolumeFromBox: (camera: PerspectiveCamera, viewBox: Box3) => void;
+export declare class SceneVolume {
+    bounds: Box3;
+    size: Vector3;
+    center: Vector3;
+    maxSceneDistanceFromCenter: number;
+    maxSceneDistanceFrom0: number;
+    copyFrom(other: SceneVolume): void;
+    updateFromObject(sceneObject: Object3D): void;
+    updateFromBox(boundingBox: Box3): void;
+    updateCameraViewVolumeFromBounds(camera: Camera): void;
+    getNearAndFarForPerspectiveCamera(cameraPosition: Vector3, backScale?: number): number[];
+}
+export declare const getMaxSamples: (renderTarget: WebGLRenderer) => number;
+export declare class BoxUpdateHelper {
+    box: Box3;
+    color: Color;
+    opacity: number;
+    private group;
+    private boxMesh;
+    private boxWire;
+    get visible(): boolean;
+    set visible(isVisible: boolean);
+    get object(): Object3D;
+    constructor(box: Box3, parameters?: any);
+    update(): void;
+    addTo(scene: Object3D): void;
+    removeFrom(scene: Object3D): void;
+}
+export declare const boxFromOrthographicViewVolume: (camera: OrthographicCamera) => Box3;
+export declare const boundingBoxInViewSpace: (worldBox: Box3, camera: Camera) => Box3;
+export declare class CameraUpdate {
+    private lastCameraProjection;
+    private lastCameraWorld;
+    changed(camera: Camera): boolean;
+}
+export declare const viewSpacePositionFromAltitudeAndAzimuth: (distance: number, altitudeDeg: number, azimuthDeg: number) => Vector3;
+export declare const viewSpacePositionFromUV: (distance: number, u: number, v: number) => Vector3;
+export declare const spiralQuadraticSampleKernel: (kernelSize: number) => Vector3[];
+export declare const generateUniformKernelRotations: () => DataTexture;
+export declare class RenderOverrideVisibility {
+    private _visibilityCache;
+    private background;
+    private hideLinesAndPoints;
+    onIsObjectInvisible?: (object: any) => boolean;
+    constructor(hideLinesAndPoints?: boolean, onIsObjectInvisible?: (object: any) => boolean, background?: any);
+    updateVisibilityCache(scene?: Scene): void;
+    render(scene: Scene, renderMethod: () => void): void;
+}
+export declare class RenderPass {
+    private originalClearColor;
+    private originalClearAlpha;
+    private originalAutoClear;
+    private originalRenderTarget;
+    private screenSpaceQuad;
+    renderWithOverrideMaterial(renderer: WebGLRenderer, scene: Scene, camera: Camera, overrideMaterial: Material | null, renderTarget: WebGLRenderTarget | null, clearColor?: any, clearAlpha?: any): void;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera, renderTarget: WebGLRenderTarget | null, clearColor?: any, clearAlpha?: any): void;
+    renderScreenSpace(renderer: WebGLRenderer, passMaterial: Material, renderTarget: WebGLRenderTarget | null, clearColor?: any, clearAlpha?: any): void;
+    private prepareRenderer;
+    private backup;
+    private restore;
+}
+export declare class BlurPass {
+    private renderPass;
+    private blurMaterial;
+    constructor(blurShaderParameters?: ShaderMaterialParameters, parameters?: any);
+    dispose(): void;
+    render(renderer: WebGLRenderer, renderTargets: WebGLRenderTarget[], uvMin: number[], uvMax: number[]): void;
+}
+export declare const changeEnvironmentMapIntensity: (objectContainer: Object3D, intensity: number) => void;
+export interface DenoisePass {
+    get texture(): Texture | null;
+    set inputTexture(texture: Texture | null);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+}

package/lib/definitions/common-core/src/webgl/renderer/scene-renderer-gui.d.ts

@@ -0,0 +1,16 @@
+import { SceneRenderer } from './scene-renderer';
+import { GUI } from 'dat.gui';
+export declare class SceneRendererGUI {
+    private sceneRenderer;
+    private qualityLevel;
+    private ambientOcclusionType;
+    constructor(sceneRenderer: SceneRenderer);
+    addGUI(gui: GUI, updateCallback: () => void): void;
+    private addRepresentationalGUI;
+    private addDebugGUI;
+    addShadowTypeGUI(gui: GUI, updateCallback: () => void): void;
+    private addShadowAndAoGUI;
+    private addGroundReflectionGUI;
+    private addBakedGroundContactShadowGUI;
+    private addOutlineGUI;
+}

package/lib/definitions/common-core/src/webgl/renderer/scene-renderer.d.ts

@@ -0,0 +1,111 @@
+import { SceneVolume } from './render-utility';
+import { GBufferParameters, GBufferRenderTargets } from './gbuffer-render-target';
+import { BakedGroundContactShadow, BakedGroundContactShadowParameters } from './baked-ground-contact-shadow';
+import { OutlineParameters, OutLineRenderer } from './outline-renderer';
+import { ScreenSpaceShadowMap, ScreenSpaceShadowMapParameters } from './screen-space-shadow-map';
+import { ShadowAndAoPass, ShadowAndAoPassParameters, ShadowBlurType } from './shadow-and-ao-pass';
+import { GroundReflectionParameters, GroundReflectionPass } from './ground-reflection-pass';
+import { LightSource } from './light-source-detection';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
+import { Pass } from 'three/examples/jsm/postprocessing/Pass';
+import { Box3, Camera, Group, Object3D, PerspectiveCamera, RectAreaLight, Scene, ShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+export { BakedGroundContactShadowParameters } from './baked-ground-contact-shadow';
+export { OutlineParameters } from './outline-renderer';
+export { AmbientOcclusionType, ShadowAndAoParameters, ShadowAndAoPassParameters, } from './shadow-and-ao-pass';
+export declare enum SceneGroupType {
+    OBJECTS = 0,
+    GROUND = 1,
+    ENVIRONMENT = 2,
+    LIGHTS = 3
+}
+export declare enum QualityLevel {
+    HIGHEST = 0,
+    HIGH = 1,
+    MEDIUM = 2,
+    LOW = 3
+}
+export interface SceneRendererParameters {
+    gBufferRenderTargetParameters: GBufferParameters;
+    shAndAoPassParameters: ShadowAndAoPassParameters;
+    screenSpaceShadowMapParameters: ScreenSpaceShadowMapParameters;
+    groundReflectionParameters: GroundReflectionParameters;
+    bakedGroundContactShadowParameters: BakedGroundContactShadowParameters;
+    outlineParameters: OutlineParameters;
+    deferredShadowAndAoFrame: number;
+    shadowAndAoFadeInFrames: number;
+    shadowOnCameraChange: ShadowBlurType;
+}
+export declare class SceneRenderer {
+    parameters: SceneRendererParameters;
+    debugOutput: string;
+    private prevDebugOutput;
+    shadowOnGround: boolean;
+    outputColorSpace: string;
+    toneMapping: string;
+    environmentLights: boolean;
+    movingCamera: boolean;
+    groundLevel: number;
+    private noUpdateNeededCount;
+    private cameraUpdate;
+    renderer: WebGLRenderer;
+    width: number;
+    height: number;
+    private maxSamples;
+    private cameraChanged;
+    boundingVolume: SceneVolume;
+    private debugRenderOverrideVisibility;
+    private shadowRenderOverrideVisibility;
+    private renderPass;
+    shadowAndAoPass: ShadowAndAoPass;
+    screenSpaceShadow: ScreenSpaceShadowMap;
+    groundReflectionPass: GroundReflectionPass;
+    gBufferRenderTarget: GBufferRenderTargets;
+    bakedGroundContactShadow: BakedGroundContactShadow;
+    effectComposer: EffectComposer;
+    scenePass: ScenePass;
+    outlineRenderer: OutLineRenderer;
+    selectedObjects: Object3D[];
+    private grayMaterial;
+    private copyMaterial?;
+    sceneGroups: SceneGroups;
+    readonly groundGroup: Group;
+    private debugPass?;
+    private qualityLevel;
+    constructor(renderer: WebGLRenderer, width: number, height: number);
+    private addEventListeners;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    setQualityLevel(qualityLevel: QualityLevel): void;
+    getQualityLevel(): QualityLevel;
+    forceShadowUpdates(updateBakedGroundShadow: boolean): void;
+    updateParameters(parameters: any): void;
+    protected getCopyMaterial(parameters?: any): ShaderMaterial;
+    addRectAreaLight(rectAreaLight: RectAreaLight, parent: Object3D): void;
+    updateRectAreaLights(rectAreaLights: RectAreaLight[], parent: Object3D): void;
+    createShadowFromEnvironmentMap(parent: Object3D, equirectangularTexture: Texture, textureData?: any): void;
+    createShadowFromLightSources(parent: Object3D, lightSources: LightSource[]): void;
+    selectObjects(selectedObjects: Object3D[]): void;
+    updateBounds(bounds: Box3, scaleShadowAndAo: boolean): void;
+    updateNearAndFarPlaneOfPerspectiveCamera(camera: PerspectiveCamera, minimumFar?: number): void;
+    private setRenderState;
+    private forceEnvironmentMapUpdate;
+    private updateEnvironment;
+    render(scene: Scene, camera: Camera, renderPostEffects: boolean): void;
+    private renderGroundContactShadow;
+    private renderDebug;
+    private renderScene;
+    private renderShadowAndAo;
+    private evaluateIfShadowAndAoUpdateIsNeeded;
+    private renderOutline;
+}
+declare class ScenePass extends Pass {
+    private renderFunction;
+    constructor();
+    setRenderFunction(renderFunction: (renderer: WebGLRenderer) => void): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, _readBuffer: WebGLRenderTarget, _deltaTime: number, _maskActive: boolean): void;
+}
+export declare class SceneGroups {
+    sceneGroups: Map<SceneGroupType, Object3D<import("three").Event>[]>;
+    addToGroup(group: SceneGroupType, object: Object3D): void;
+    setVisibilityOfGroup(group: SceneGroupType, visible: boolean): void;
+}

package/lib/definitions/common-core/src/webgl/renderer/screen-space-shadow-map.d.ts

@@ -0,0 +1,139 @@
+import { SceneVolume } from './render-utility';
+import { LightSource } from './light-source-detection';
+import { Camera, Layers, Light, Object3D, RectAreaLight, Scene, ShadowMapType, Texture, Vector2, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare enum ShadowLightSourceType {
+    DirectionalLightShadow = 0,
+    SpotLightShadow = 1
+}
+export interface ScreenSpaceShadowMapParameters {
+    [key: string]: any;
+    alwaysUpdate: boolean;
+    enableShadowMap: boolean;
+    layers: Layers | null;
+    shadowLightSourceType: ShadowLightSourceType;
+    maximumNumberOfLightSources: number;
+}
+interface ActiveShadowLight {
+    light: Light;
+    intensity: number;
+}
+export interface ShadowLightSource {
+    getPosition(): Vector3;
+    getShadowLight(): Light;
+    getOriginalLight(): Light | null;
+    dispose(): void;
+    addTo(object: Object3D): void;
+    removeFrom(object: Object3D): void;
+    updatePositionAndTarget(): void;
+    updateBounds(sceneBounds: SceneVolume): void;
+    updateShadowType(typeParameters: ShadowTypeParameters, shadowScale: number): void;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export declare class ScreenSpaceShadowMap {
+    parameters: ScreenSpaceShadowMapParameters;
+    needsUpdate: boolean;
+    shadowTypeNeedsUpdate: boolean;
+    shadowConfiguration: ShadowTypeConfiguration;
+    private shadowLightSources;
+    private shadowMapPassOverrideMaterials;
+    private viewportSize;
+    private samples;
+    private shadowScale;
+    private shadowMapSize;
+    castShadow: boolean;
+    private shadowRenderTarget;
+    private cameraUpdate;
+    get shadowTexture(): Texture;
+    constructor(viewportSize: Vector2, parameters: any);
+    private getScreenSpaceShadowMapParameters;
+    dispose(): void;
+    updateParameters(parameters: any): void;
+    updateBounds(sceneBounds: SceneVolume, scaleShadow: number): void;
+    getShadowLightSources(): Light[];
+    findShadowLightSource(lightSource: Light): Light | undefined;
+    addRectAreaLight(rectAreaLight: RectAreaLight, parent: Object3D): void;
+    updateRectAreaLights(rectAreaLights: RectAreaLight[], parent: Object3D): void;
+    createShadowFromLightSources(parent: Object3D, lightSources: LightSource[]): void;
+    private addShadowFromLightSources;
+    setSize(width: number, height: number): void;
+    updatePositionAndTarget(): void;
+    renderShadowMap(renderer: WebGLRenderer, scene: Scene, camera: Camera): void;
+    private renderSimpleShadowMapFromShadowLightSources;
+    private getSortedShadowLightSources;
+    private setShadowLightSourcesIntensity;
+    private updateShadowType;
+    switchType(type: string): boolean;
+}
+export declare class ShadowMapPassOverrideMaterials {
+    static useModifiedMaterial: boolean;
+    private renderPass;
+    private shadowObjetMaterial;
+    private unlitMaterial;
+    private emissiveMaterial;
+    private receiveShadowMaterial;
+    constructor();
+    dispose(): void;
+    private createShadowMaterial;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera, renderTarget: WebGLRenderTarget): void;
+    private setMeshMaterialAndVisibility;
+    private setMeshShadowStandardMaterial;
+}
+export interface ShadowTypeParameters {
+    castShadow: boolean;
+    type: ShadowMapType;
+    bias: number;
+    normalBias: number;
+    radius: number;
+}
+export declare class ShadowTypeConfiguration {
+    private static noShadow;
+    private static basicShadow;
+    private static pcfShadow;
+    private static pcfSoftShadow;
+    private static vcmShadow;
+    types: Map<string, ShadowTypeParameters>;
+    private static defaultType;
+    shadowType: string;
+    currentConfiguration: ShadowTypeParameters;
+    switchType(type: any): boolean;
+}
+declare abstract class BaseShadowLightSource implements ShadowLightSource {
+    protected _shadowLightSource: Light;
+    protected shadowMapSize: number;
+    protected blurSamples: number;
+    protected isVisibleBackup: boolean;
+    protected castShadowBackup: boolean;
+    constructor(lightSource: Light, parameters: any);
+    getPosition(): Vector3;
+    getShadowLight(): Light;
+    getOriginalLight(): Light | null;
+    dispose(): void;
+    addTo(parent: Object3D): void;
+    removeFrom(parent: Object3D): void;
+    updatePositionAndTarget(): void;
+    updateBounds(sceneBounds: SceneVolume): void;
+    protected updateShadowPositionAndTarget(cameraPosition: Vector3, targetPosition: Vector3): void;
+    updateShadowType(typeParameters: ShadowTypeParameters, shadowScale: number): void;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export declare class RectAreaShadowLightSource extends BaseShadowLightSource {
+    private _rectAreaLight;
+    private _rectLightHelper?;
+    constructor(rectAreaLight: RectAreaLight, parameters: any);
+    getPosition(): Vector3;
+    getRectAreaLight(): RectAreaLight;
+    getOriginalLight(): Light | null;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export declare class EnvironmentShadowLightSource extends BaseShadowLightSource {
+    private position;
+    private intensity;
+    constructor(position: Vector3, lightIntensity: number, parameters: any);
+    getPosition(): Vector3;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export {};

package/lib/definitions/common-core/src/webgl/renderer/shader-utility.d.ts

@@ -0,0 +1,98 @@
+import { Matrix3, Matrix4, ShaderMaterial, Texture, Vector2, Vector4 } from 'three';
+export declare const DEFAULT_TRANSFORM: Matrix4;
+export declare const RGB_TRANSFORM: Matrix4;
+export declare const ALPHA_TRANSFORM: Matrix4;
+export declare const RED_TRANSFORM: Matrix4;
+export declare const GRAYSCALE_TRANSFORM: Matrix4;
+export declare const ZERO_RGBA: Vector4;
+export declare const ALPHA_RGBA: Vector4;
+export declare const DEFAULT_UV_TRANSFORM: Matrix3;
+export declare const FLIP_Y_UV_TRANSFORM: Matrix3;
+export declare const interpolationMatrix: (r: number, g: number, b: number, a: number) => Matrix4;
+export declare enum CopyMaterialBlendMode {
+    DEFAULT = 0,
+    ADDITIVE = 1
+}
+export declare class CopyTransformMaterial extends ShaderMaterial {
+    constructor(parameters?: Record<string, any>, copyBlendMode?: CopyMaterialBlendMode);
+    update(parameters?: Record<string, any>): CopyTransformMaterial;
+}
+export declare const BlurShader: {
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        rangeMin: {
+            value: Vector2;
+        };
+        rangeMax: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const MixShadowShader: {
+    uniforms: {
+        tShadow1: {
+            value: Texture;
+        };
+        tShadow2: {
+            value: Texture;
+        };
+        shadowScale1: {
+            value: number;
+        };
+        shadowScale2: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const HorizontalBlurShadowShader: {
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        blur: {
+            value: number;
+        };
+        shadowRange: {
+            value: Vector2;
+        };
+    };
+    defines: {
+        DEBUG_BLUR_AREA: number;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const VerticalBlurShadowShader: {
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        blur: {
+            value: number;
+        };
+        shadowRange: {
+            value: Vector2;
+        };
+    };
+    defines: {
+        DEBUG_BLUR_AREA: number;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare class LinearDepthRenderMaterial extends ShaderMaterial {
+    private static linearDepthShader;
+    constructor(parameters: Record<string, any>);
+    update(parameters?: Record<string, any>): LinearDepthRenderMaterial;
+}
+export declare class NormalAndDepthRenderMaterial extends ShaderMaterial {
+    private static normalAndDepthShader;
+    constructor(parameters: Record<string, any>);
+    update(parameters?: Record<string, any>): NormalAndDepthRenderMaterial;
+}