@roomle/embedding-lib 5.24.0-alpha.1 → 5.25.0-alpha.1

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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,78 @@
+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';
+
+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, 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): void;
+    private _renderGroundContact;
+    private _renderBlur;
+    private _renderReduceBandingBlur;
+    private _renderBlurPass;
+}

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,69 @@
+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';
+
+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): 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

@@ -0,0 +1,74 @@
+import { RenderPass } from './render-pass';
+import { RenderPassManager } from '../render-pass-manager';
+import { Camera, Texture, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
+
+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): 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

@@ -0,0 +1,64 @@
+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';
+
+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, _writeBuffer: WebGLRenderTarget | null, readBuffer: WebGLRenderTarget | null, _deltaTime: number, maskActive: boolean): void;
+    renderPass(renderer: WebGLRenderer): void;
+    private _getPrepareMaskMaterial;
+    private _getEdgeDetectionMaterial;
+    private _getSeperableBlurMaterial;
+    private _getOverlayMaterial;
+}

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

@@ -0,0 +1,13 @@
+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>;

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

@@ -0,0 +1,68 @@
+import { DenoisePass } from './../render-utility';
+import { NormalVectorSourceType, DepthValueSourceType } from './pass-utility';
+import { Camera, Texture, WebGLRenderer, Box3, WebGLRenderTarget } from 'three';
+
+export interface PoissonDenoisePassParameters {
+    [key: string]: any;
+    iterations: number;
+    samples: number;
+    rings: number;
+    radiusExponent: number;
+    radius: number;
+    lumaPhi: number;
+    depthPhi: number;
+    normalPhi: number;
+    nvOrientatedSamples?: boolean;
+}
+export declare const defaultPoissonDenoisePassParameters: PoissonDenoisePassParameters;
+export interface PoissonDenoiseParameters {
+    poissonDenoisePassParameters?: PoissonDenoisePassParameters;
+    normalVectorSourceType?: NormalVectorSourceType;
+    depthValueSourceType?: DepthValueSourceType;
+    rgInputTexture?: boolean;
+    luminanceWeighted?: boolean;
+    luminanceType?: string;
+    sampleLuminance?: string;
+    fragmentOutput?: string;
+    inputTexture?: Texture;
+    depthTexture?: Texture;
+    normalTexture?: Texture;
+}
+export declare class PoissonDenoiseRenderPass implements DenoisePass {
+    needsUpdate: boolean;
+    parameters: PoissonDenoisePassParameters;
+    private _width;
+    private _height;
+    private _samples;
+    private _normalVectorSourceType;
+    private _depthValueSourceType;
+    _inputTexture: Texture | null;
+    depthTexture: Texture | null;
+    normalTexture: Texture | null;
+    private _noiseTexture;
+    private _pdMaterial?;
+    private _renderTargets;
+    private _outputRenderTargetIndex;
+    private _passRenderer;
+    private _sceneClipBox;
+    private _rgInputTexture;
+    private _luminanceWeighted;
+    private _luminanceType;
+    private _sampleLuminance;
+    private _fragmentOutput;
+    get texture(): Texture | null;
+    set inputTexture(texture: Texture | null);
+    constructor(width: number, height: number, samples: number, parameters?: PoissonDenoiseParameters);
+    private _getNoiseTexture;
+    private _getMaterial;
+    private _updateShader;
+    private _updateUniforms;
+    private _getRenderTargets;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateBounds(sceneClipBox: Box3): void;
+    updateParameters(parameters: PoissonDenoisePassParameters): void;
+    updateTextures(parameters: PoissonDenoiseParameters): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+    renderToTarget(renderer: WebGLRenderer, camera: Camera, renderTarget: WebGLRenderTarget): void;
+}

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

@@ -0,0 +1,19 @@
+import { PassRenderer } from '../render-utility';
+import { RenderCacheManager } from '../render-cache';
+import { RenderPassManager } from '../render-pass-manager';
+import { GBufferTextures } from './gbuffer-render-pass';
+import { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from 'three/examples/jsm/postprocessing/Pass';
+
+export declare abstract class RenderPass extends Pass {
+    private _renderPassManager;
+    protected get renderPassManager(): RenderPassManager;
+    protected get renderCacheManager(): RenderCacheManager;
+    protected get scene(): Scene;
+    protected get camera(): Camera;
+    protected get gBufferTextures(): GBufferTextures;
+    protected get passRenderer(): PassRenderer;
+    constructor(renderPassManager: RenderPassManager);
+    render(renderer: WebGLRenderer, _writeBuffer: WebGLRenderTarget, _readBuffer: WebGLRenderTarget, _deltaTime: number, _maskActive: boolean): void;
+    abstract renderPass(renderer: WebGLRenderer): void;
+}

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

@@ -0,0 +1,12 @@
+import { RenderPass } from './render-pass';
+import { RenderPassManager } from '../render-pass-manager';
+import { WebGLRenderer, MeshStandardMaterial } from 'three';
+
+export declare class SceneRenderPass extends RenderPass {
+    drawGround: boolean;
+    drawWithDebugMaterial: boolean;
+    grayDebugMaterial: MeshStandardMaterial;
+    constructor(renderPassManager: RenderPassManager);
+    dispose(): void;
+    renderPass(renderer: WebGLRenderer): void;
+}