The FragmentFilter class is the base class for all filter effects in Starling. All filters must extend this class. You can attach them to any display object through the `filter` property.

A fragment filter works in the following way:

1. The object to be filtered is rendered into a texture.
2. That texture is passed to the `process` method.
3. This method processes the texture using a `FilterEffect` subclass that processes the input via fragment and vertex shaders to achieve a certain effect.
4. If the filter requires several passes, the process method may execute the effect several times, or even make use of other filters in the process.
5. In the end, a quad with the output texture is added to the batch renderer. In the next frame, if the object hasn't changed, the filter is drawn directly from the render cache.
6. Alternatively, the last pass may be drawn directly to the back buffer. That saves one draw call, but means that the object may not be drawn from the render cache in the next frame. Starling makes an educated guess if that makes sense, but you can also force it to do so via the `alwaysDrawToBackBuffer` property.

All of this is set up by the basic FragmentFilter class. Concrete subclasses just need to override the protected method `createEffect` and (optionally) `process`. Multi-pass filters must also override `numPasses`.

Typically, any properties on the filter are just forwarded to an effect instance, which is then used automatically by `process` to render the filter pass. For a simple example on how to write a single-pass filter, look at the implementation of the `ColorMatrixFilter`; for a composite filter (i.e. a filter that combines several others), look at the `GlowFilter`.

Beware that a filter instance may only be used on one object at a time!

Animated filters

The `process` method of a filter is only called when it's necessary, i.e. when the filter properties or the target display object changes. This means that you cannot rely on the method to be called on a regular basis, as needed when creating an animated filter class. Instead, you can do so by listening for an `ENTER_FRAME`-event. It is dispatched on the filter once every frame, as long as the filter is assigned to a display object that is connected to the stage.

Caching

Per default, whenever the target display object is changed in any way (i.e. the render cache fails), the filter is reprocessed. However, you can manually cache the filter output via the method of the same name: this will let the filter redraw the current output texture, even if the target object changes later on. That's especially useful if you add a filter to an object that changes only rarely, e.g. a TextField or an Image. Keep in mind, though, that you have to call `cache()` again in order for any changes to show up.

@see starling.rendering.FilterEffect

### Hierarchy

- EventDispatcher
  - FragmentFilter
    - BlurFilter
    - ColorMatrixFilter
    - CompositeFilter
    - DisplacementMapFilter
    - DropShadowFilter
    - FilterChain
    - GlowFilter

## Index

### Constructors

- constructor

### Properties

- alwaysDrawToBackBuffer
- antiAliasing
- isCached
- maintainResolutionAcrossPasses
- padding
- resolution
- textureFormat
- textureSmoothing

### Methods

- addEventListener
- cache
- clearCache
- dispatchEvent
- dispatchEventWith
- dispose
- get_alwaysDrawToBackBuffer
- get_antiAliasing
- get_isCached
- get_maintainResolutionAcrossPasses
- get_padding
- get_resolution
- get_textureFormat
- get_textureSmoothing
- hasEventListener
- process
- removeEventListener
- removeEventListeners
- render
- set_alwaysDrawToBackBuffer
- set_antiAliasing
- set_maintainResolutionAcrossPasses
- set_padding
- set_resolution
- set_textureFormat
- set_textureSmoothing

## Constructors

### constructor

- new FragmentFilter(): FragmentFilter

- Overrides EventDispatcher.constructor

  - Defined in lib/starling/filters/FragmentFilter.d.ts:88

  Creates a new instance. The base class' implementation just draws the unmodified input texture.

  #### Returns FragmentFilter

## Properties

### alwaysDrawToBackBuffer

alwaysDrawToBackBuffer: boolean

- Defined in lib/starling/filters/FragmentFilter.d.ts:214

Indicates if the last filter pass is always drawn directly to the back buffer.

Per default, the filter tries to automatically render in a smart way: objects that are currently moving are rendered to the back buffer, objects that are static are rendered into a texture first, which allows the filter to be drawn directly from the render cache in the next frame (in case the object remains static).

However, this fails when filters are added to an object that does not support the render cache, or to a container with such a child (e.g. a Sprite3D object or a masked display object). In such a case, enable this property for maximum performance.

@default false

### antiAliasing

antiAliasing: number

- Defined in lib/starling/filters/FragmentFilter.d.ts:187

The anti-aliasing level. This is only used for rendering the target object into a texture, not for the filter passes. 0 - none, 4 - maximum. @default 0

### isCached

isCached: boolean

- Defined in lib/starling/filters/FragmentFilter.d.ts:158

Indicates if the filter is cached (via the `cache` method).

### Protected maintainResolutionAcrossPasses

maintainResolutionAcrossPasses: boolean

- Defined in lib/starling/filters/FragmentFilter.d.ts:181

Indicates if the filter requires all passes to be processed with the exact same resolution.

Some filters must use the same resolution for input and output; e.g. the blur filter is very sensitive to changes of pixel / texel sizes. When the filter is used as part of a filter chain, or if its last pass is drawn directly to the back buffer, such a filter produces artifacts. In that case, the filter author must set this property to `true`.

@default false

### padding

padding: Padding

- Defined in lib/starling/filters/FragmentFilter.d.ts:152

Padding can extend the size of the filter texture in all directions. That's useful when the filter "grows" the bounds of the object in any direction.

### resolution

resolution: number

- Defined in lib/starling/filters/FragmentFilter.d.ts:166

The resolution of the filter texture. "1" means stage resolution, "0.5" half the stage resolution. A lower resolution saves memory and execution time, but results in a lower output quality. Values greater than 1 are allowed; such values might make sense for a cached filter when it is scaled up. @default 1

### textureFormat

textureFormat: string

- Defined in lib/starling/filters/FragmentFilter.d.ts:197

The format of the filter texture. @default BGRA

### textureSmoothing

textureSmoothing: string

- Defined in lib/starling/filters/FragmentFilter.d.ts:192

The smoothing mode of the filter texture. @default bilinear

## Methods

### Protected addEventListener

- addEventListener(type: string, listener: Function): void

- Overrides EventDispatcher.addEventListener

  - Defined in lib/starling/filters/FragmentFilter.d.ts:143

  #### Parameters

  - ##### type: string

  - ##### listener: Function

  #### Returns void

### cache

- cache(): void

- - Defined in lib/starling/filters/FragmentFilter.d.ts:134

  Caches the filter output into a texture.

  An uncached filter is rendered every frame (except if it can be rendered from the global render cache, which happens if the target object does not change its appearance or location relative to the stage). A cached filter is only rendered once; the output stays unchanged until you call `cache` again or change the filter settings.

  Beware: you cannot cache filters on 3D objects; if the object the filter is attached to is a Sprite3D or has a Sprite3D as (grand-) parent, the request will be silently ignored. However, you can cache a 2D object that has 3D children!

  #### Returns void

### clearCache

- clearCache(): void

- - Defined in lib/starling/filters/FragmentFilter.d.ts:138

  Clears the cached output of the filter. After calling this method, the filter will be processed once per frame again.

  #### Returns void

### dispatchEvent

- dispatchEvent(event: Event): void

- Inherited from EventDispatcher.dispatchEvent

  - Defined in lib/starling/events/EventDispatcher.d.ts:45

  Dispatches an event to all objects that have registered listeners for its type. If an event with enabled 'bubble' property is dispatched to a display object, it will travel up along the line of parents, until it either hits the root object or someone stops its propagation manually.

  #### Parameters

  - ##### event: Event

  #### Returns void

### dispatchEventWith

- dispatchEventWith(type: string, bubbles?: boolean, data?: any): void

- Inherited from EventDispatcher.dispatchEventWith

  - Defined in lib/starling/events/EventDispatcher.d.ts:50

  Dispatches an event with the given parameters to all objects that have registered listeners for the given type. The method uses an internal pool of event objects to avoid allocations.

  #### Parameters

  - ##### type: string

  - ##### Optional bubbles: boolean

  - ##### Optional data: any

  #### Returns void

### dispose

- dispose(): void

- - Defined in lib/starling/filters/FragmentFilter.d.ts:94

  Disposes all resources that have been created by the filter.

  #### Returns void

### Protected get_alwaysDrawToBackBuffer

- get_alwaysDrawToBackBuffer(): boolean

- - Defined in lib/starling/filters/FragmentFilter.d.ts:215

  #### Returns boolean

### Protected get_antiAliasing

- get_antiAliasing(): number

- - Defined in lib/starling/filters/FragmentFilter.d.ts:188

  #### Returns number

### Protected get_isCached

- get_isCached(): boolean

- - Defined in lib/starling/filters/FragmentFilter.d.ts:159

  #### Returns boolean

### Protected get_maintainResolutionAcrossPasses

- get_maintainResolutionAcrossPasses(): boolean

- - Defined in lib/starling/filters/FragmentFilter.d.ts:182

  #### Returns boolean

### Protected get_padding

- get_padding(): Padding

- - Defined in lib/starling/filters/FragmentFilter.d.ts:153

  #### Returns Padding

### Protected get_resolution

- get_resolution(): number

- - Defined in lib/starling/filters/FragmentFilter.d.ts:167

  #### Returns number

### Protected get_textureFormat

- get_textureFormat(): string

- - Defined in lib/starling/filters/FragmentFilter.d.ts:198

  #### Returns string

### Protected get_textureSmoothing

- get_textureSmoothing(): string

- - Defined in lib/starling/filters/FragmentFilter.d.ts:193

  #### Returns string

### hasEventListener

- hasEventListener(type: string, listener?: any): boolean

- Inherited from EventDispatcher.hasEventListener

  - Defined in lib/starling/events/EventDispatcher.d.ts:55

  If called with one argument, figures out if there are any listeners registered for the given event type. If called with two arguments, also determines if a specific listener is registered.

  #### Parameters

  - ##### type: string

  - ##### Optional listener: any

  #### Returns boolean

### process

- process(painter: Painter, helper: IFilterHelper, input0?: Texture, input1?: Texture, input2?: Texture, input3?: Texture): Texture

- - Defined in lib/starling/filters/FragmentFilter.d.ts:118

  Does the actual filter processing. This method will be called with up to four input textures and must return a new texture (acquired from the `helper`) that contains the filtered output. To to do this, it configures the FilterEffect (provided via `createEffect`) and calls its `render` method.

  In a standard filter, only `input0` will contain a texture; that's the object the filter was applied to, rendered into an appropriately sized texture. However, filters may also accept multiple textures; that's useful when you need to combine the output of several filters into one. For example, the DropShadowFilter uses a BlurFilter to create the shadow and then feeds both input and shadow texture into a CompositeFilter.

  Never create or dispose any textures manually within this method; instead, get new textures from the provided helper object, and pass them to the helper when you do not need them any longer. Ownership of both input textures and returned texture lies at the caller; only temporary textures should be put into the helper.

  #### Parameters

  - ##### painter: Painter

  - ##### helper: IFilterHelper

  - ##### Optional input0: Texture

  - ##### Optional input1: Texture

  - ##### Optional input2: Texture

  - ##### Optional input3: Texture

  #### Returns Texture

### Protected removeEventListener

- removeEventListener(type: string, listener: Function): void

- Overrides EventDispatcher.removeEventListener

  - Defined in lib/starling/filters/FragmentFilter.d.ts:146

  #### Parameters

  - ##### type: string

  - ##### listener: Function

  #### Returns void

### removeEventListeners

- removeEventListeners(type?: string): void

- Inherited from EventDispatcher.removeEventListeners

  - Defined in lib/starling/events/EventDispatcher.d.ts:39

  Removes all event listeners with a certain type, or all of them if type is null. Be careful when removing all event listeners: you never know who else was listening.

  #### Parameters

  - ##### Optional type: string

  #### Returns void

### render

- render(painter: Painter): void

- - Defined in lib/starling/filters/FragmentFilter.d.ts:99

  Renders the filtered target object. Most users will never have to call this manually; it's executed automatically in the rendering process of the filtered display object.

  #### Parameters

  - ##### painter: Painter

  #### Returns void

### Protected set_alwaysDrawToBackBuffer

- set_alwaysDrawToBackBuffer(value: boolean): boolean

- - Defined in lib/starling/filters/FragmentFilter.d.ts:216

  #### Parameters

  - ##### value: boolean

  #### Returns boolean

### Protected set_antiAliasing

- set_antiAliasing(value: number): number

- - Defined in lib/starling/filters/FragmentFilter.d.ts:189

  #### Parameters

  - ##### value: number

  #### Returns number

### Protected set_maintainResolutionAcrossPasses

- set_maintainResolutionAcrossPasses(value: boolean): boolean

- - Defined in lib/starling/filters/FragmentFilter.d.ts:183

  #### Parameters

  - ##### value: boolean

  #### Returns boolean

### Protected set_padding

- set_padding(value: Padding): Padding

- - Defined in lib/starling/filters/FragmentFilter.d.ts:155

  #### Parameters

  - ##### value: Padding

  #### Returns Padding

### Protected set_resolution

- set_resolution(value: number): number

- - Defined in lib/starling/filters/FragmentFilter.d.ts:168

  #### Parameters

  - ##### value: number

  #### Returns number

### Protected set_textureFormat

- set_textureFormat(value: string): string

- - Defined in lib/starling/filters/FragmentFilter.d.ts:199

  #### Parameters

  - ##### value: string

  #### Returns string

### Protected set_textureSmoothing

- set_textureSmoothing(value: string): string

- - Defined in lib/starling/filters/FragmentFilter.d.ts:194

  #### Parameters

  - ##### value: string

  #### Returns string

Generated using TypeDoc