Some components, such as Blur, Motion Blur, and High Pass, are called bitmap-based because they implicitly render an internal bitmap of their source input in order to produce their result. While these components provide operations that aren't usually available in procedural texturing software, they have several disadvantages.
First, internal bitmaps consume memory, which may cause disk swapping and slow down the rendering. Second, filters that use bitmap-based components may respond slowly when a user changes their controls – this effect is known as the 'first block delay'. For example, for a filter that uses Blur, the first blurred block requires at least nine source bitmap blocks to be rendered, which causes the delay. And third, there is a precision loss which happens due to the conversion of the procedurally-defined 'signal' into an inherently less precise bitmapped form.
Because of these disadvantages, bitmap-based components should be used only when necessary. Always try to avoid using bitmap-based components. For example, if you want a soft blurry Perlin Noise, you can simply lower its Roughness instead of blurring the noise, which may seem the easiest way.
Note that you cannot use bitmap-based components in any component chain between a slave component and their master component, such as Loop or Bomber Plus. Bitmap-based components remove the element data sent to slaves by their master and thus cannot be used in slave-to-master connections.
Normally, Filter Forge's renderer doesn't produce any intermediate bitmaps. Instead of rendering a bitmap for every component in the filter tree and passing these bitmaps between the components, Filter Forge uses a procedural approach – it builds an image function based on the filter component tree and evaluates it for every pixel of the resulting image (when anti-aliasing is turned on, a single pixel may require multiple evaluations – or 'samples' – of the image function, which will be averaged to produce the resulting pixel color).
However, some operations need multiple neighboring source samples in order to produce a single resulting sample. Examples of such operations are Blur, Motion Blur, and High Pass. For example, Blur takes all pixels within its radius and averages their colors to produce a resulting 'blurred' pixel. Such operations are significantly faster when performed on bitmap instead of direct source sampling, because the bitmap serves as a cache preventing unnecessary multiple evaluations of neighboring samples.
To preserve accuracy, the internal bitmaps use single-precision floating point pixel format (the internal bitmaps of components in the Height subtree of the Result and the Refraction components are stored in double precision, though). However, even a floating-point bitmap is inherently less precise than a procedurally-defined signal, so connecting a bitmap-based component to a distorter such as Refraction, Offset or Noise Distortion may produce 'fuzzy edges' because of the bicubic filtration which is performed during the sampling of the internal bitmap.
Generally, bitmap-based components cannot be used in slave-to-master connections because they destroy the data that are sent to slave components by their master, thus preventing the slave components from altering their output according to the data their master sent them.
The Result component is a notable exception from this. Slaves of the Result component will affect the output of a bitmap-based component, however, any further components on the path between the output of that bitmap-based component and Result's Surface Color input will not be affected. For more information about this case, see the 'Using Slave Components' section of the help article for the Result component.
