The DepthOfFieldBlurPostProcess applied a blur in a give direction. This blur differs from the standard BlurPostProcess as it attempts to avoid blurring pixels based on samples that have a large difference in distance than the center pixel. See section 2.6.2





  • Creates a new instance CircleOfConfusionPostProcess


    • name: string

      The name of the effect.

    • scene: Scene

      The scene the effect belongs to.

    • direction: Vector2

      The direction the blur should be applied.

    • kernel: number

      The size of the kernel used to blur.

    • options: number | PostProcessOptions

      The required width/height ratio to downsize to before computing the render pass.

    • camera: Nullable<Camera>

      The camera to apply the render pass to.

    • circleOfConfusion: PostProcess

      The circle of confusion + depth map to be used to avoid blurring accross edges

    • Optional imageToBlur: Nullable<PostProcess>

      The image to apply the blur to (default: Current rendered frame)

    • Optional samplingMode: number

      The sampling mode to be used when computing the pass. (default: 0)

    • Optional engine: Engine

      The engine which the post process will be applied. (default: current engine)

    • Optional reusable: boolean

      If the post process can be reused on the same frame. (default: false)

    • Optional textureType: number

      Type of textures used when performing the post process. (default: 0)

    • Optional blockCompilation: boolean

      If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)

    Returns DepthOfFieldBlurPostProcess



adaptScaleToCurrentViewport: boolean

Modify the scale of the post process to be the same as the viewport (default: false)


alphaConstants: Color4

Sets the setAlphaBlendConstants of the babylon engine


alphaMode: number

Type of alpha mode to use when performing the post process (default: Engine.ALPHA_DISABLE)


alwaysForcePOT: boolean

Force textures to be a power of two (default: false)


animations: Animation[]

Animations to be used for the post processing


aspectRatio: number

The aspect ratio of the output texture.


autoClear: boolean

If the buffer needs to be cleared before applying the post process. (default: true) Should be set to false if shader will overwrite all previous pixels.


clearColor: Color4

Clear color to use when screen clearing


direction: Vector2


enablePixelPerfectMode: boolean

Enable Pixel Perfect mode where texture is not scaled to be power of 2. Can only be used on a single postprocess or on the last one of a chain. (default: false)


forceFullscreenViewport: boolean

Force the postprocess to be applied without taking in account viewport


height: number

Height of the texture to apply the post process on


inputTexture: InternalTexture

The input texture for this post process and the output texture of the previous post process. When added to a pipeline the previous post process will render it's output into this texture and this texture will be used as textureSampler in the fragment shader of this post process.


isSupported: boolean

If the post process is supported.


kernel: number

Gets the length in pixels of the blur sample region


name: string

Name of the PostProcess.


onActivate: Nullable<function>

A function that is added to the onActivateObservable


onActivateObservable: Observable<Camera>

An event triggered when the postprocess is activated.


onAfterRender: function

A function that is added to the onAfterRenderObservable

Type declaration

    • Parameters

      Returns void


onAfterRenderObservable: Observable<Effect>

An event triggered after rendering the postprocess


onApply: function

A function that is added to the onApplyObservable

Type declaration

    • Parameters

      Returns void


onApplyObservable: Observable<Effect>

An event triggered when the postprocess applies its effect.


onBeforeRender: function

A function that is added to the onBeforeRenderObservable

Type declaration

    • Parameters

      Returns void


onBeforeRenderObservable: Observable<Effect>

An event triggered before rendering the postprocess


onSizeChanged: function

A function that is added to the onSizeChangedObservable

Type declaration


onSizeChangedObservable: Observable<PostProcess>

An event triggered when the postprocess changes its size.


packedFloat: boolean

Gets wether or not the blur is unpacking/repacking floats


renderTargetSamplingMode: number

Sampling mode used by the shader See


samples: number

Number of sample textures (default: 1)


scaleMode: number

Scale mode for the post process (default: Engine.SCALEMODE_FLOOR)

Value Type Description
1 SCALEMODE_FLOOR engine.scalemode_floor
2 SCALEMODE_NEAREST engine.scalemode_nearest
3 SCALEMODE_CEILING engine.scalemode_ceiling


texelSize: Vector2

Gets the texel size of the postprocess. See


width: number

Width of the texture to apply the post process on



  • Activates the post process by intializing the textures to be used when executed. Notifies onActivateObservable. When this post process is used in a pipeline, this is call will bind the input texture of this post process to the output of the previous.


    • camera: Nullable<Camera>

      The camera that will be used in the post process. This camera will be used when calling onActivateObservable.

    • Optional sourceTexture: Nullable<InternalTexture>

      The source texture to be inspected to get the width and height if not specified in the post process constructor. (default: null)

    • Optional forceDepthStencil: boolean

      If true, a depth and stencil buffer will be generated. (default: false)

    Returns InternalTexture

    The target texture that was bound to be written to.


  • Binds all textures and uniforms to the shader, this will be run on every pass.

    Returns Nullable<Effect>

    the effect corrisponding to this post process. Null if not compiled or not ready.


  • dispose(camera?: Camera): void
  • Disposes the post process.


    • Optional camera: Camera

      The camera to dispose the post process on.

    Returns void


  • Gets the camera which post process is applied to.

    Returns Camera

    The camera the post process is applied to.


  • The effect that is created when initializing the post process.

    Returns Effect

    The created effect corrisponding the the postprocess.


  • Gets the engine which this post process belongs to.

    Returns Engine

    The engine the post process was enabled with.


  • isReady(): boolean
  • Get a value indicating if the post-process is ready to be used

    Returns boolean

    true if the post-process is ready (shader is compiled)


  • isReusable(): boolean
  • The post process is reusable if it can be used multiple times within one frame.

    Returns boolean

    If the post process is reusable


  • markTextureDirty(): void


  • To avoid multiple redundant textures for multiple post process, the output the output texture for this post process can be shared with another.


    • postProcess: PostProcess

      The post process to share the output with.

    Returns PostProcess

    This post process.


  • updateEffect(defines?: Nullable<string>, uniforms?: Nullable<string[]>, samplers?: Nullable<string[]>, indexParameters?: any, onCompiled?: function, onError?: function): void
  • Updates the effect with the current post process compile time values and recompiles the shader.


    • Optional defines: Nullable<string>

      Define statements that should be added at the beginning of the shader. (default: null)

    • Optional uniforms: Nullable<string[]>

      Set of uniform variables that will be passed to the shader. (default: null)

    • Optional samplers: Nullable<string[]>

      Set of Texture2D variables that will be passed to the shader. (default: null)

    • Optional indexParameters: any

      The index parameters to be used for babylons include syntax "#include[0..varyingCount]". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx

    • Optional onCompiled: function

      Called when the shader has been compiled.

        • Parameters

          Returns void

    • Optional onError: function

      Called if there is an error when compiling a shader.

        • (effect: Effect, errors: string): void
        • Parameters

          • effect: Effect
          • errors: string

          Returns void

    Returns void


  • useOwnOutput(): void
  • Reverses the effect of calling shareOutputWith and returns the post process back to its original state. This should be called if the post process that shares output with this post process is disabled/disposed.

    Returns void

Generated using TypeDoc