Returns the size of the desired convolution kernel for the given pass as it would be applied in the coordinate space indicated by the getInputKernelSize(int) method. This value is calculated at the start of the render operation and does not vary as the filter operation progresses, but it may not represent the actual kernel size used when the indicated pass actually occurs if the validatePassInput() method needs to choose different values when it sees the incoming image source.

Parameters

pass:int

the pass for which the intended kernel size is desired

Returns:int

the intended kernel size for the requested pass

Returns the appropriate kernel size for the pass that was last validated using validateInput().

Returns:int

the pixel kernel size of the current pass

Return the EffectPeer to be used to perform the currently validated pass of the convolution operation, or null if this pass is a NOP.

Parameters

r:Renderer

the Renderer being used for this filter operation

fctx:FilterContext

the FilterContext being used for this filter operation

Returns:EffectPeer<? extends LinearConvolveRenderState>

the EffectPeer to use for this pass, or null

Returns the size of the scaled result image needed to hold the output for the currently validated pass with the indicated input dimensions and output clip. The image may be further scaled after the shader operation is through to obtain the final result bounds. This value is only of use to the actual shader to understand exactly how much room to allocate for the shader result.

Parameters

srcdimension:Rectangle

the bounds of the input image

outputClip:Rectangle

the area needed for the final result

Returns:Rectangle

the bounds of the result image for the current pass

For a shadow convolution operation, return the 4 float versions of the color components, in the range [0, 1] for the shadow color to be substituted for the input colors. This method will only be called if isShadow() returns true.

Returns:float[]

the array of 4 floats representing the shadow color components

Return a hint about the way that the weights will be applied to the pixels for the currently validated pass.

Returns:LinearConvolveRenderState.PassType

the appropriate PassType that describes the filtering operation for this pass of the algorithm

Returns an array of 4 floats used to initialize a float4 Shader constant with the relative starting location of the first weight in the convolution kernel and the incremental offset between each sample to be weighted and accumulated. The values are stored in the array in the following order:

    shadervec.x = vector[0] = incdx // X delta between subsequent samples
    shadervec.y = vector[1] = incdy // Y delta between subsequent samples
    shadervec.z = vector[2] = startdx // X offset to first convolution sample
    shadervec.w = vector[3] = startdy // Y offset to first convolution sample

    samplelocation = outputpixellocation.xy + shadervec.zw;
    for (each weight) {
        sum += weight * sample(samplelocation.xy);
        samplelocation.xy += shadervec.xy;
    }

Returns:float[]

an array of 4 floats representing [ incdx, incdy, startdx, startdy ]

A FloatBuffer padded out to the required size as specified by the getPeerSize() method filled with the convolution weights needed for the currently validated pass.

Returns:FloatBuffer

a FloatBuffer containing the kernel convolution weights

Returns the maximum number of valid float4 elements that should be referenced from the buffer returned by getWeights() for the currently validated pass.

Returns:int

the maximum number of valid float4 elements in the weights buffer

Returns the peer sample count for a given kernel size. There are only a few peers defined to operate on specific sizes of convolution kernel. If there are peers defined only for kernel sizes of 8 and 16 and a given effect has a linear convolution kernel with 5 weights, then the peer for size 8 will be used and the buffer of weights must be padded out to the appropriate size with 0s so that the shader constant pool will be fully initialized and the extra unneeded convolution samples will be ignored by the 0 weights.

Parameters

ksize:int

the number of computed convolution kernel weights

Returns:int

the number of convolution weights which will be applied by the associated peer.

Returns the Color4f representing the shadow color if this is a shadow operation. This value is dependent only on the original Effect from which this RenderState was instantiated and does not vary as the filter operation progresses.

Returns:Color4f

the Color4f for the shadow color, or null

Returns true if the resulting operation is globally a NOP operation. This condition is calculated at the start of the render operation and is based on whether the perturbations of the convolution kernel would be noticeable at all in the coordinate space of the output.

Returns:boolean

true if the operation is a global NOP

Returns true if the operation of the currently validated pass would be a NOP operation.

Returns:boolean

true if the current pass is a NOP

Returns true if this is a shadow convolution operation where a constant color is substituted for the color components of the output. This value is dependent only on the original Effect from which this RenderState was instantiated and does not vary as the filter operation progresses.

Returns:boolean

true if this is a shadow operation

Validates the RenderState object for a given pass of the convolution. The supplied source image is provided so that the RenderState object can determine if it needs to change its strategy for how the convolution operation will be performed and to scale its data for the getPass*() methods relative to the source dimensions and transform.

Parameters

src:ImageData

the ImageData object supplied by the source effect

pass:int

the pass of the operation being applied (usually horizontal for pass 0 and vertical for pass 1)

Returns:ImageData

the ImageData to be used for the actual convolution operation