API
API|
@babylonjs/core|
SSRRenderingPipeline

Class SSRRenderingPipeline

Render pipeline to produce Screen Space Reflections (SSR) effect

References: Screen Space Ray Tracing: - http://casual-effects.blogspot.com/2014/08/screen-space-ray-tracing.html - https://sourceforge.net/p/g3d/code/HEAD/tree/G3D10/data-files/shader/screenSpaceRayTrace.glsl - https://github.com/kode80/kode80SSR SSR: - general tips: https://sakibsaikia.github.io/graphics/2016/12/26/Screen-Space-Reflection-in-Killing-Floor-2.html - computation of blur radius from roughness and distance: https://github.com/godotengine/godot/blob/master/servers/rendering/renderer_rd/shaders/effects/screen_space_reflection.glsl - blur and usage of back depth buffer: https://github.com/kode80/kode80SSR

Hierarchy (View Summary)

Index
constructor
inspectableCustomProperties SSRBlurRenderEffect SSRCombineRenderEffect SSRRenderEffect uniqueId
attenuateBackfaceReflection attenuateFacingCamera attenuateIntersectionDistance attenuateIntersectionIterations attenuateScreenBorders backfaceDepthRenderer backfaceDepthTextureDownsample backfaceForceDepthWriteTransparentMeshes blurDispersionStrength blurDownsample cameras clipToFrustum debug enableAutomaticThicknessComputation enableSmoothReflections engine environmentTexture environmentTextureIsProbe generateOutputInGammaSpace inputTextureColorIsInGammaSpace isEnabled isSupported maxDistance maxSteps name reflectionSpecularFalloffExponent reflectivityThreshold roughnessFactor samples scene selfCollisionNumSkip ssrDownsample step strength thickness useFresnel
addCamera addEffect dispose getClassName getScene isReady removeCamera serialize setPrePassRenderer

  • Constructor of the SSR rendering pipeline

    Parameters

    • name: string

      The rendering pipeline name

    • scene: Scene

      The scene linked to this pipeline

    • Optionalcameras: Camera[]

      The array of cameras that the rendering pipeline will be attached to (default: scene.cameras)

    • forceGeometryBuffer: boolean = false

      Set to true if you want to use the legacy geometry buffer renderer (default: false)

    • textureType: number = Constants.TEXTURETYPE_UNSIGNED_BYTE

      The texture type used by the different post processes created by SSR (default: Constants.TEXTURETYPE_UNSIGNED_BYTE)

    • useScreenspaceDepth: boolean = false

      Indicates if the depth buffer should be linear or screenspace (default: false). This allows sharing the buffer with other effect pipelines that may require the depth to be in screenspace.

    Returns SSRRenderingPipeline

inspectableCustomProperties: IInspectable[]

List of inspectable custom properties (used by the Inspector)

https://doc.babylonjs.com/toolsAndResources/inspector#extensibility

SSRBlurRenderEffect: string = "SSRBlurRenderEffect"

The blur PostProcess effect id in the pipeline

SSRCombineRenderEffect: string = "SSRCombineRenderEffect"

The PostProcess effect id in the pipeline that combines the SSR-Blur output with the original scene color

SSRRenderEffect: string = "SSRRenderEffect"

The SSR PostProcess effect id in the pipeline

uniqueId: any = UniqueIdGenerator.UniqueId

Gets the unique id of the post process rendering pipeline

  • get debug(): boolean

    Gets or sets a boolean indicating if the effect should be rendered in debug mode (default: false). In this mode, colors have this meaning:

    • blue: the ray hit the max distance (we reached maxDistance)
    • red: the ray ran out of steps (we reached maxSteps)
    • yellow: the ray went off screen
    • green: the ray hit a surface. The brightness of the green color is proportional to the distance between the ray origin and the intersection point: A brighter green means more computation than a darker green. In the first 3 cases, the final color is calculated by mixing the skybox color with the pixel color (if environmentTexture is defined), otherwise the pixel color is not modified You should try to get as few blue/red/yellow pixels as possible, as this means that the ray has gone further than if it had hit a surface.

    Returns boolean

  • set debug(value: boolean): void

    Parameters

    • value: boolean

    Returns void

  • get enableAutomaticThicknessComputation(): boolean

    Gets or sets a boolean defining if geometry thickness should be computed automatically (default: false). When enabled, a depth renderer is created which will render the back faces of the scene to a depth texture (meaning additional work for the GPU). In that mode, the "thickness" property is still used as an offset to compute the ray intersection, but you can typically use a much lower value than when enableAutomaticThicknessComputation is false (it's even possible to use a value of 0 when using low values for "step") Note that for performance reasons, this option will only apply to the first camera to which the rendering pipeline is attached!

    Returns boolean

  • set enableAutomaticThicknessComputation(automatic: boolean): void

    Parameters

    • automatic: boolean

    Returns void