@roomle/embedding-lib 5.34.0-alpha.1 → 5.34.0-debug.1

package/packages/web-sdk/packages/common-core/src/webgl/renderer/light-source-detection.d.ts

@@ -1,88 +0,0 @@
-import { WebGLRenderer, OrthographicCamera, ShaderMaterial, Texture, Vector2, Vector3, WebGLRenderTarget } from 'three';
-import { default as WebGPURenderer } from 'three/src/renderers/webgpu/WebGPURenderer';
-import { EnvironmentDefinitionTextureData } from './environment-definition';
-
-export declare const sphereToEquirectangular: (pointOnSphere: Vector3) => Vector2;
-export declare const equirectangularToSphere: (uv: Vector2) => Vector3;
-export interface TextureConverterResult {
-    texture: Texture;
-    pixels: Uint8Array | Float32Array;
-    sRgbaPixels: boolean;
-}
-export declare class TextureConverter {
-    private _colorRenderTarget?;
-    private _environmentMapDecodeTarget?;
-    private _equirectangularDecodeMaterial?;
-    private _pmremDecodeMaterial?;
-    private _camera?;
-    private _planeMesh?;
-    get colorRenderTarget(): WebGLRenderTarget;
-    environmentMapDecodeTarget(renderer: WebGLRenderer | WebGPURenderer): WebGLRenderTarget;
-    environmentMapDecodeMaterial(decodePmrem: boolean): EnvironmentMapDecodeMaterial;
-    get camera(): OrthographicCamera;
-    scaleTexture(renderer: WebGLRenderer | WebGPURenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
-    newGrayscaleTexture(renderer: WebGLRenderer | WebGPURenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
-}
-export declare class EnvironmentMapDecodeMaterial extends ShaderMaterial {
-    constructor(decodePmrem: boolean, grayscale: boolean);
-    setSourceTexture(map: Texture): void;
-}
-export interface LightSourceDetectorParameters {
-    numberOfSamples?: number;
-    width?: number;
-    height?: number;
-    sampleThreshold?: number;
-}
-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[];
-    private _grayScale;
-    constructor(parameters?: LightSourceDetectorParameters);
-    detectLightSources(renderer: WebGLRenderer | WebGPURenderer, equirectangularTexture: Texture, textureData?: EnvironmentDefinitionTextureData): 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/packages/web-sdk/packages/common-core/src/webgl/renderer/materials/blend-ao-and-shadow-material.d.ts

@@ -1,14 +0,0 @@
-import { Blending, Texture, ShaderMaterial } from 'three';
-import { Nullable } from '../../../../../typings/helper';
-
-export interface BlendAoAndAShadowMaterialParameters {
-    texture?: Nullable<Texture>;
-    blending?: Blending;
-    aoIntensity?: number;
-    shadowIntensity?: number;
-}
-export declare class BlendAoAndAShadowMaterial extends ShaderMaterial {
-    private _intensity;
-    constructor(parameters?: BlendAoAndAShadowMaterialParameters);
-    update(parameters?: BlendAoAndAShadowMaterialParameters): BlendAoAndAShadowMaterial;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/materials/blend-ao-pass-depth-material.d.ts

@@ -1,12 +0,0 @@
-import { Blending, Texture, ShaderMaterial } from 'three';
-import { Nullable } from '../../../../../typings/helper';
-
-export interface BlendAoPassDepthMaterialParameters {
-    texture?: Nullable<Texture>;
-    blending?: Blending;
-}
-export declare class BlendAoPassDepthMaterial extends ShaderMaterial {
-    private _intensity;
-    constructor(parameters?: BlendAoPassDepthMaterialParameters);
-    update(parameters?: BlendAoPassDepthMaterialParameters): BlendAoPassDepthMaterial;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/materials/illumination-buffer-material.d.ts

@@ -1,14 +0,0 @@
-import { Box3, MeshLambertMaterial } from 'three';
-
-export declare class IlluminationBufferMaterial extends MeshLambertMaterial {
-    private static _enableGroundBoundary;
-    private static _shadowFadeOut;
-    private static _sceneBoxMin;
-    private static _sceneBoxMax;
-    private static _distributionProperties;
-    constructor(parameters?: any);
-    static setShadowParameters(enableGroundBoundary: boolean, directionalDependency: number, directionalExponent: number, groundBoundary: number, groundMapScale: number, distance: number, blur: number): void;
-    static setBoundingBox(box: Box3): void;
-    private _customProgramCacheKey;
-    private _onBeforeCompile;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/materials/normal-depth-material.d.ts

@@ -1,14 +0,0 @@
-import { Blending, Camera, MeshNormalMaterial, ShaderMaterial } from 'three';
-
-export interface GBufferNormalDepthMaterialParameters {
-    floatBufferType?: boolean;
-    linearDepth?: boolean;
-    camera?: Camera;
-    blending?: Blending;
-}
-export type GBufferNormalDepthMaterial = NormalAndDepthRenderMaterial | MeshNormalMaterial;
-export declare class NormalAndDepthRenderMaterial extends ShaderMaterial {
-    private static _normalAndDepthShader;
-    constructor(parameters: GBufferNormalDepthMaterialParameters);
-    update(parameters?: GBufferNormalDepthMaterialParameters): NormalAndDepthRenderMaterial;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/materials/postprocessing-material-plugin.d.ts

@@ -1,26 +0,0 @@
-import { MeshStandardMaterial, Texture } from 'three';
-import { Nullable } from '../../../../../typings/helper';
-
-export declare class PostProcessingMaterialPlugin {
-    applyAoAndShadowToAlpha: boolean;
-    private _aoPassMapUniform;
-    private _aoPassMapScaleUniform;
-    private _aoPassMapIntensityUniform;
-    private _shPassMapIntensityUniform;
-    private _reflectionPassMapUniform;
-    private _reflectionPassMapScaleUniform;
-    private _reflectionPassMapIntensityUniform;
-    applyReflectionPassMap: boolean;
-    set aoPassMap(value: Nullable<Texture>);
-    set aoPassMapScale(value: number);
-    set aoPassMapIntensity(value: number);
-    set shPassMapIntensity(value: number);
-    set reflectionPassMap(value: Nullable<Texture>);
-    set reflectionPassMapScale(value: number);
-    set reflectionPassMapIntensity(value: number);
-    static addPlugin(material: MeshStandardMaterial): PostProcessingMaterialPlugin | null;
-    private _isEnabled;
-    private _customProgramCacheKey;
-    private _onBeforeCompile;
-    private _initUniforms;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/objects/shadow-ground-plane.d.ts

@@ -1,16 +0,0 @@
-import { Texture, Mesh } from 'three';
-
-export interface ShadowGroundPlaneParameters {
-    opacity?: number;
-    polygonOffset?: number;
-}
-export declare class ShadowGroundPlane extends Mesh {
-    static alphaMap: boolean;
-    constructor(shadowMap: Texture | null, parameters?: ShadowGroundPlaneParameters);
-    setVisibility(visible: boolean): void;
-    setVisibilityLayers(visible: boolean): void;
-    setDepthWrite(write: boolean): void;
-    setReceiveShadow(receive: boolean): void;
-    setShadowMap(shadowMap: Texture | null): void;
-    updateMaterial(parameters: ShadowGroundPlaneParameters): void;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/outline-renderer.d.ts

@@ -1,40 +0,0 @@
-import { RenderPassManager } from './render-pass-manager';
-import { OutlinePass } from './pass/outline-pass';
-import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
-import { Camera, ColorRepresentation, Object3D, Scene } from 'three';
-
-export interface OutlineParameters {
-    [key: string]: any;
-    enabled: boolean;
-    edgeStrength: number;
-    edgeGlow: number;
-    edgeThickness: number;
-    pulsePeriod: number;
-    usePatternTexture: false;
-    visibleEdgeColor: ColorRepresentation;
-    hiddenEdgeColor: ColorRepresentation;
-}
-export interface OutlineRendererParameters {
-    enabled?: boolean;
-    edgeStrength?: number;
-    edgeGlow?: number;
-    edgeThickness?: number;
-    pulsePeriod?: number;
-    usePatternTexture?: false;
-    visibleEdgeColor?: ColorRepresentation;
-    hiddenEdgeColor?: ColorRepresentation;
-}
-export declare class OutlineRenderer {
-    parameters: OutlineParameters;
-    private _renderPassManager;
-    private _effectComposer;
-    outlinePassActivated: boolean;
-    get isOutlinePassActivated(): boolean;
-    get outlinePass(): OutlinePass | null;
-    constructor(renderPassManager: RenderPassManager, _effectComposer: EffectComposer | null, parameters: OutlineRendererParameters);
-    updateParameters(parameters: OutlineParameters): void;
-    applyParameters(): void;
-    activateOutline(scene: Scene, camera: Camera): void;
-    deactivateOutline(): void;
-    updateOutline(scene: Scene, camera: Camera, selectedObjects: Object3D[]): void;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/ao-pass.d.ts

@@ -1,61 +0,0 @@
-import { NormalVectorSourceType, DepthValueSourceType } from './pass-utility';
-import { AoAlgorithmType } from '../shaders/ao-shader';
-import { Camera, Scene, Texture, WebGLRenderer, Box3, WebGLRenderTarget } from 'three';
-
-export { AO_ALGORITHMS, type AoAlgorithmType } from '../shaders/ao-shader';
-export interface AORenderPassParameters {
-    [key: string]: any;
-    resolutionScale: number;
-    algorithm: AoAlgorithmType;
-    samples: number;
-    radius: number;
-    distanceExponent: number;
-    thickness: number;
-    distanceFallOff: number;
-    scale: number;
-    bias: number;
-    screenSpaceRadius: boolean;
-}
-export declare const defaultAORenderPassParameters: AORenderPassParameters;
-export interface AOPassParameters {
-    aoParameters?: AORenderPassParameters;
-    normalVectorSourceType?: NormalVectorSourceType;
-    depthValueSourceType?: DepthValueSourceType;
-    modulateRedChannel?: boolean;
-    depthTexture?: Texture;
-    normalTexture?: Texture;
-}
-export declare class AORenderPass {
-    needsUpdate: boolean;
-    parameters: AORenderPassParameters;
-    private _width;
-    private _height;
-    private _samples;
-    private _gBufferAntiAliasing;
-    private _normalVectorSourceType;
-    private _depthValueSourceType;
-    private _modulateRedChannel;
-    depthTexture: Texture | null;
-    normalTexture: Texture | null;
-    private _noiseTexture;
-    private _aoMaterial?;
-    private _renderTarget;
-    private _passRenderer;
-    private _sceneClipBox;
-    private _sceneScale;
-    get texture(): Texture | null;
-    constructor(width: number, height: number, samples: number, gBufferAntiAliasing: boolean, parameters?: AOPassParameters);
-    private _getNoiseTexture;
-    private _getMaterial;
-    private _newAoMaterial;
-    private _updateShader;
-    private _updateUniforms;
-    private _getRenderTargets;
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    updateBounds(sceneClipBox: Box3, sceneScale?: number): void;
-    updateParameters(parameters: AORenderPassParameters): void;
-    updateTextures(parameters: AOPassParameters): void;
-    clear(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget): void;
-    render(renderer: WebGLRenderer, camera: Camera, _scene: Scene, renderTarget?: WebGLRenderTarget): void;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/baked-ground-contact-shadow-pass.d.ts

@@ -1,79 +0,0 @@
-import { SceneVolume } from '../render-utility';
-import { ShadowGroundPlane } from '../objects/shadow-ground-plane';
-import { RenderPass } from './render-pass';
-import { RenderPassManager } from '../render-pass-manager';
-import { Group, Layers, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { default as WebGPURenderer } from 'three/src/renderers/webgpu/WebGPURenderer';
-
-export interface BakedGroundContactShadowParameters {
-    [key: string]: any;
-    enabled: boolean;
-    cameraHelper: boolean;
-    alwaysUpdate: boolean;
-    fadeIn: boolean;
-    blurMin: number;
-    blurMax: number;
-    fadeoutFalloff: number;
-    fadeoutBias: number;
-    opacity: number;
-    maximumPlaneSize: number;
-    planeSize: number;
-    cameraFar: number;
-    hardLayers: Layers | null;
-    softLayers: Layers | null;
-    polygonOffset: number;
-}
-export interface BakedGroundContactShadowConstructorParameters {
-    sharedShadowGroundPlane?: ShadowGroundPlane;
-    shadowMapSize?: number;
-    enabled?: boolean;
-    cameraHelper?: boolean;
-    alwaysUpdate?: boolean;
-    fadeIn?: boolean;
-    blurMin?: number;
-    blurMax?: number;
-    fadeoutFalloff?: number;
-    fadeoutBias?: number;
-    opacity?: number;
-    maximumPlaneSize?: number;
-    planeSize?: number;
-    cameraFar?: number;
-    hardLayers?: Layers | null;
-    softLayers?: Layers | null;
-    polygonOffset?: number;
-}
-export declare class BakedGroundContactShadowPass extends RenderPass {
-    static addTestMesh: boolean;
-    shadowMapSize: number;
-    limitPlaneSize: boolean;
-    parameters: BakedGroundContactShadowParameters;
-    private _renderer;
-    needsUpdate: boolean;
-    noNeedOfUpdateCount: number;
-    private _blurScale;
-    private _shadowScale;
-    private _groundGroup;
-    private _groundShadowFar;
-    private _sharedShadowGroundPlane?;
-    private _shadowGroundPlane?;
-    private _groundContactCamera;
-    private _renderTargetBlur;
-    private _blurPass;
-    readonly renderTarget: WebGLRenderTarget;
-    private _depthMaterial;
-    get shadowGroundPlane(): ShadowGroundPlane;
-    constructor(renderPassManager: RenderPassManager, renderer: WebGLRenderer | WebGPURenderer, groundGroup: Group, parameters: BakedGroundContactShadowConstructorParameters);
-    private _getDefaultParameters;
-    dispose(): void;
-    updateParameters(parameters: BakedGroundContactShadowParameters): void;
-    applyParameters(): void;
-    setScale(groundContactShadowScale: number, _shadowScale?: number): void;
-    updateBounds(sceneBounds: SceneVolume, groundLevel?: number): void;
-    updatePlaneAndShadowCamera(): void;
-    setGroundVisibilityLayers(visible: boolean): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _renderGroundContact;
-    private _renderBlur;
-    private _renderReduceBandingBlur;
-    private _renderBlurPass;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/debug-pass.d.ts

@@ -1,24 +0,0 @@
-import { RenderPass } from './render-pass';
-import { RenderPassManager } from '../render-pass-manager';
-import { CopyTransformMaterialParameters } from '../shader-utility';
-import { BlendAoAndAShadowMaterialParameters } from '../materials/blend-ao-and-shadow-material';
-import { BlendAoPassDepthMaterialParameters } from '../materials/blend-ao-pass-depth-material';
-import { ShaderMaterial, WebGLRenderer } from 'three';
-
-export declare class DebugPass extends RenderPass {
-    private _environmentMapDecodeMaterial;
-    private _copyMaterial?;
-    private _blendAoAndShadowMaterial?;
-    private _blendAoPassDepthMaterial?;
-    private _srgbToLinearCopyMaterial?;
-    private _depthRenderMaterial?;
-    debugOutput: string;
-    constructor(renderPassManager: RenderPassManager);
-    dispose(): void;
-    protected getCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
-    protected getBlendAoAndShadowMaterial(parameters?: BlendAoAndAShadowMaterialParameters): ShaderMaterial;
-    protected getBlendAoPassDepthMaterial(parameters?: BlendAoPassDepthMaterialParameters): ShaderMaterial;
-    protected getSrgbToLinearCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
-    private _getDepthRenderMaterial;
-    renderPass(renderer: WebGLRenderer): void;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/gbuffer-render-pass.d.ts

@@ -1,70 +0,0 @@
-import { RenderPass } from './render-pass';
-import { RenderPassManager } from '../render-pass-manager';
-import { CopyTransformMaterialParameters } from '../shader-utility';
-import { ObjectRenderCache } from '../render-cache';
-import { Camera, MagnificationTextureFilter, Mesh, Object3D, ShaderMaterial, Texture, TextureFilter, WebGLRenderer, Material, WebGLRenderTarget } from 'three';
-import { default as WebGPURenderer } from 'three/src/renderers/webgpu/WebGPURenderer';
-
-export interface GBufferTextures {
-    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
-    get gBufferTexture(): Texture;
-    get depthBufferTexture(): Texture;
-    get textureWithDepthValue(): Texture;
-}
-export interface GBufferParameters {
-    [key: string]: any;
-    depthNormalScale: number;
-}
-export interface GBufferRenderTargetsParameters {
-    capabilities?: any;
-    textureMinificationFilter?: TextureFilter;
-    textureMagnificationFilter?: MagnificationTextureFilter;
-    width?: number;
-    height?: number;
-    samples?: number;
-    shared?: boolean;
-    depthNormalScale?: number;
-}
-export declare class GBufferRenderPass extends RenderPass implements GBufferTextures {
-    parameters: GBufferParameters;
-    readonly floatRgbNormalAlphaDepth: boolean;
-    readonly linearDepth: boolean;
-    copyToSeparateDepthBuffer: boolean;
-    private _gBufferMaterialCache?;
-    private _targetMinificationTextureFilter;
-    private _targetMagnificationTextureFilter;
-    private _width;
-    private _height;
-    private _samples;
-    private _gBufferRenderMaterial?;
-    private _depthNormalRenderTarget?;
-    private _separateDeptRenderTarget?;
-    private _copyMaterial?;
-    private _shared;
-    needsUpdate: boolean;
-    drawGround: boolean;
-    set groundDepthWrite(value: boolean);
-    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
-    get gBufferTexture(): Texture;
-    get depthBufferTexture(): Texture;
-    get textureWithDepthValue(): Texture;
-    updateGBufferRenderMaterial(camera: Camera): Material;
-    get depthNormalRenderTarget(): WebGLRenderTarget;
-    get separateDeptRenderTarget(): WebGLRenderTarget;
-    constructor(renderPassManager: RenderPassManager, parameters?: GBufferRenderTargetsParameters);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _renderGBuffer;
-    protected getCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
-    private _copyDepthToSeparateDepthTexture;
-}
-export declare class GBufferMaterialCache extends ObjectRenderCache {
-    private _groundDepthWrite;
-    set groundDepthWrite(value: boolean);
-    constructor();
-    dispose(): void;
-    addLineOrPoint(object3d: Object3D): void;
-    addMesh(mesh: Mesh): void;
-    addObject(object3d: Object3D): void;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/ground-reflection-pass.d.ts

@@ -1,75 +0,0 @@
-import { RenderPass } from './render-pass';
-import { RenderPassManager } from '../render-pass-manager';
-import { Camera, Texture, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
-import { default as WebGPURenderer } from 'three/src/renderers/webgpu/WebGPURenderer';
-
-export interface GroundReflectionParameters {
-    [key: string]: any;
-    enabled: boolean;
-    intensity: number;
-    fadeOutDistance: number;
-    fadeOutExponent: number;
-    brightness: number;
-    blurHorizontal: number;
-    blurVertical: number;
-    blurAscent: number;
-    groundLevel: number;
-    groundReflectionScale: number;
-    renderTargetDownScale: number;
-}
-export interface GroundReflectionConstructorParameters {
-    enabled?: boolean;
-    intensity?: number;
-    fadeOutDistance?: number;
-    fadeOutExponent?: number;
-    brightness?: number;
-    blurHorizontal?: number;
-    blurVertical?: number;
-    blurAscent?: number;
-    groundLevel?: number;
-    groundReflectionScale?: number;
-    renderTargetDownScale?: number;
-}
-export declare class GroundReflectionPass extends RenderPass {
-    private _width;
-    private _height;
-    private _samples;
-    parameters: GroundReflectionParameters;
-    reflectionFadeInScale: number;
-    private _reflectionRenderTarget?;
-    private _intensityRenderTarget?;
-    private _blurRenderTarget?;
-    private _blurPass;
-    private _reflectionIntensityMaterial;
-    private _copyMaterial;
-    get reflectionRenderTarget(): WebGLRenderTarget;
-    get intensityRenderTarget(): WebGLRenderTarget;
-    get blurRenderTarget(): WebGLRenderTarget;
-    constructor(renderPassManager: RenderPassManager, width: number, height: number, samples: number, parameters: GroundReflectionConstructorParameters);
-    private _newRenderTarget;
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    updateParameters(parameters: GroundReflectionParameters): void;
-    updateBounds(groundLevel: number, groundReflectionScale: number): void;
-    private _updateCopyMaterial;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _renderGroundReflection;
-    private _renderGroundReflectionIntensity;
-    blurReflection(renderer: WebGLRenderer, camera: Camera, renderTargets: WebGLRenderTarget[]): void;
-    private _createGroundReflectionCamera;
-}
-export interface GroundReflectionIntensityMaterialParameters {
-    texture?: Texture;
-    depthTexture?: Texture;
-    camera?: Camera;
-    groundLevel?: number;
-    fadeOutDistance?: number;
-    fadeOutExponent?: number;
-    width?: number;
-    height?: number;
-}
-export declare class GroundReflectionIntensityMaterial extends ShaderMaterial {
-    private static shader;
-    constructor(parameters?: GroundReflectionIntensityMaterialParameters);
-    update(parameters?: GroundReflectionIntensityMaterialParameters): GroundReflectionIntensityMaterial;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/outline-pass.d.ts

@@ -1,65 +0,0 @@
-import { RenderPass } from './render-pass';
-import { RenderPassManager } from '../render-pass-manager';
-import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
-import { Camera, Object3D, Scene, Texture, WebGLRenderer, Color, Matrix4, ShaderMaterial, Vector2, WebGLRenderTarget } from 'three';
-import { default as WebGPURenderer } from 'three/src/renderers/webgpu/WebGPURenderer';
-
-export interface OutlinePassParameters {
-    downSampleRatio?: number;
-    edgeDetectionFxaa?: boolean;
-}
-export declare class OutlinePass extends RenderPass {
-    static BlurDirectionX: Vector2;
-    static BlurDirectionY: Vector2;
-    static highlightLines: boolean;
-    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;
-    prepareMaskMaterial: ShaderMaterial;
-    renderTargetFxaaBuffer?: WebGLRenderTarget;
-    fxaaRenderMaterial?: ShaderMaterial;
-    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;
-    clearBackground: boolean;
-    constructor(renderPassManager: RenderPassManager, resolution: Vector2, scene: Scene, camera: Camera, selectedObjects: Object3D[], parameters?: OutlinePassParameters);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    private _canBeHighlighted;
-    private _changeVisibilityOfSelectedObjects;
-    private _changeVisibilityOfNonSelectedObjects;
-    private _updateTextureMatrix;
-    render(renderer: WebGLRenderer | WebGPURenderer, _writeBuffer: WebGLRenderTarget | null, readBuffer: WebGLRenderTarget | null, _deltaTime: number, maskActive: boolean): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _getPrepareMaskMaterial;
-    private _getEdgeDetectionMaterial;
-    private _getSeperableBlurMaterial;
-    private _getOverlayMaterial;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/pass-utility.d.ts

@@ -1,13 +0,0 @@
-import { Enumify } from '../../../types';
-
-export declare const NORMAL_VECTOR_SOURCE_TYPES: {
-    readonly INPUT_RGB_NORMAL: "inputRgbNormal";
-    readonly FLOAT_BUFFER_NORMAL: "floatBufferNormal";
-    readonly CONSTANT_Z: "constantZ";
-};
-export type NormalVectorSourceType = Enumify<typeof NORMAL_VECTOR_SOURCE_TYPES>;
-export declare const DEPTH_VALUE_SOURCE_TYPES: {
-    readonly SEPARATE_BUFFER: "separateBuffer";
-    readonly NORMAL_VECTOR_ALPHA: "normalVectorAlpha";
-};
-export type DepthValueSourceType = Enumify<typeof DEPTH_VALUE_SOURCE_TYPES>;