org.openjfx/javafx-graphics/12 : com/sun/scenario/effect/Blend.java

Blend
https://openjdk.java.net/projects/openjfx/javafx-graphics/: OpenJFX JavaFX
GPLv2+CE
OpenJFX Mailing List
/*
 * Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.scenario.effect;

import com.sun.javafx.geom.Point2D;
import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.transform.BaseTransform;
import com.sun.scenario.effect.impl.state.RenderState;

An effect that blends the two inputs together using one of the pre-defined Modes. /**
 * An effect that blends the two inputs together using one of the
 * pre-defined {@code Mode}s.
 */
public class Blend extends CoreEffect<RenderState> {

    A blending mode that defines the manner in which the inputs are composited together. Each Mode describes a mathematical equation that combines premultiplied inputs to produce some premultiplied result. /**
     * A blending mode that defines the manner in which the inputs
     * are composited together.
     * Each {@code Mode} describes a mathematical equation that
     * combines premultiplied inputs to produce some premultiplied result.
     */
    public enum Mode {
        The top input is blended over the bottom input.
(Equivalent to the Porter-Duff "source over destination" rule.)

Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = C_top + C_bot*(1-A_top)

/**
         * The top input is blended over the bottom input.
         * (Equivalent to the Porter-Duff "source over destination" rule.)
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = <em>C<sub>top</sub></em> + <em>C<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         * </pre>
         */
        SRC_OVER,

        The part of the top input lying inside of the bottom input
is kept in the resulting image.
(Equivalent to the Porter-Duff "source in destination" rule.)

Thus:
     A_r = A_top*A_bot
     C_r = C_top*A_bot

/**
         * The part of the top input lying inside of the bottom input
         * is kept in the resulting image.
         * (Equivalent to the Porter-Duff "source in destination" rule.)
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em>*<em>A<sub>bot</sub></em>
         *      <em>C<sub>r</sub></em> = <em>C<sub>top</sub></em>*<em>A<sub>bot</sub></em>
         * </pre>
         */
        SRC_IN,

        The part of the top input lying outside of the bottom input
is kept in the resulting image.
(Equivalent to the Porter-Duff "source held out by destination"
rule.)

Thus:
     A_r = A_top*(1-A_bot)
     C_r = C_top*(1-A_bot)

/**
         * The part of the top input lying outside of the bottom input
         * is kept in the resulting image.
         * (Equivalent to the Porter-Duff "source held out by destination"
         * rule.)
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em>*(1-<em>A<sub>bot</sub></em>)
         *      <em>C<sub>r</sub></em> = <em>C<sub>top</sub></em>*(1-<em>A<sub>bot</sub></em>)
         * </pre>
         */
        SRC_OUT,

        The part of the top input lying inside of the bottom input
is blended with the bottom input.
(Equivalent to the Porter-Duff "source atop destination" rule.)

Thus:
     A_r = A_top*A_bot + A_bot*(1-A_top) = A_bot
     C_r = C_top*A_bot + C_bot*(1-A_top)

/**
         * The part of the top input lying inside of the bottom input
         * is blended with the bottom input.
         * (Equivalent to the Porter-Duff "source atop destination" rule.)
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em>*<em>A<sub>bot</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>) = <em>A<sub>bot</sub></em>
         *      <em>C<sub>r</sub></em> = <em>C<sub>top</sub></em>*<em>A<sub>bot</sub></em> + <em>C<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         * </pre>
         */
        SRC_ATOP,

        The color and alpha components from the top input are
added to those from the bottom input.
The result is clamped to 1.0 if it exceeds the logical
maximum of 1.0.

Thus:
     A_r = min(1, A_top+A_bot)
     C_r = min(1, C_top+C_bot)


Notes:

This mode is commutative (ordering of inputs
does not matter).
This mode is sometimes referred to as "linear dodge" in
imaging software packages.

/**
         * The color and alpha components from the top input are
         * added to those from the bottom input.
         * The result is clamped to 1.0 if it exceeds the logical
         * maximum of 1.0.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = min(1, <em>A<sub>top</sub></em>+<em>A<sub>bot</sub></em>)
         *      <em>C<sub>r</sub></em> = min(1, <em>C<sub>top</sub></em>+<em>C<sub>bot</sub></em>)
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is commutative (ordering of inputs
         * does not matter).
         * <li>This mode is sometimes referred to as "linear dodge" in
         * imaging software packages.
         * </ul>
         */
        ADD,

        The color components from the first input are multiplied with those from the second input. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = C_top * C_bot


Notes:

This mode is commutative (ordering of inputs
does not matter).
This mode is the mathematical opposite of the SCREEN mode. 
The resulting color is always at least as dark as either
of the input colors.
Rendering with a completely black top input produces black;
rendering with a completely white top input produces a result
equivalent to the bottom input.

/**
         * The color components from the first input are multiplied with those
         * from the second input.
         * The alpha components are blended according to
         * the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = <em>C<sub>top</sub></em> * <em>C<sub>bot</sub></em>
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is commutative (ordering of inputs
         * does not matter).
         * <li>This mode is the mathematical opposite of
         * the {@link #SCREEN} mode.
         * <li>The resulting color is always at least as dark as either
         * of the input colors.
         * <li>Rendering with a completely black top input produces black;
         * rendering with a completely white top input produces a result
         * equivalent to the bottom input.
         * </ul>
         */
        MULTIPLY,

        The color components from both of the inputs are inverted, multiplied with each other, and that result is again inverted to produce the resulting color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = 1 - ((1-C_top) * (1-C_bot))


Notes:

This mode is commutative (ordering of inputs
does not matter).
This mode is the mathematical opposite of the MULTIPLY mode. 
The resulting color is always at least as light as either
of the input colors.
Rendering with a completely white top input produces white;
rendering with a completely black top input produces a result
equivalent to the bottom input.

/**
         * The color components from both of the inputs are
         * inverted, multiplied with each other, and that result
         * is again inverted to produce the resulting color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = 1 - ((1-<em>C<sub>top</sub></em>) * (1-<em>C<sub>bot</sub></em>))
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is commutative (ordering of inputs
         * does not matter).
         * <li>This mode is the mathematical opposite of
         * the {@link #MULTIPLY} mode.
         * <li>The resulting color is always at least as light as either
         * of the input colors.
         * <li>Rendering with a completely white top input produces white;
         * rendering with a completely black top input produces a result
         * equivalent to the bottom input.
         * </ul>
         */
        SCREEN,

        The input color components are either multiplied or screened, depending on the bottom input color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     REMIND: not sure how to express this succinctly yet...


Notes:

This mode is a combination of SCREEN and MULTIPLY, depending on the bottom input color. 
This mode is the mathematical opposite of the HARD_LIGHT mode. 
In this mode, the top input colors "overlay" the bottom input
while preserving highlights and shadows of the latter.

/**
         * The input color components are either multiplied or screened,
         * depending on the bottom input color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      REMIND: not sure how to express this succinctly yet...
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is a combination of {@link #SCREEN} and
         * {@link #MULTIPLY}, depending on the bottom input color.
         * <li>This mode is the mathematical opposite of
         * the {@link #HARD_LIGHT} mode.
         * <li>In this mode, the top input colors "overlay" the bottom input
         * while preserving highlights and shadows of the latter.
         * </ul>
         */
        OVERLAY,

        REMIND: cross check this formula with OpenVG spec... The darker of the color components from the two inputs are selected to produce the resulting color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = min(C_top, C_bot)


Notes:

This mode is commutative (ordering of inputs
does not matter).
This mode is the mathematical opposite of the LIGHTEN mode. 
/**
         * REMIND: cross check this formula with OpenVG spec...
         *
         * The darker of the color components from the two inputs are
         * selected to produce the resulting color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = min(<em>C<sub>top</sub></em>, <em>C<sub>bot</sub></em>)
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is commutative (ordering of inputs
         * does not matter).
         * <li>This mode is the mathematical opposite of
         * the {@link #LIGHTEN} mode.
         * </ul>
         */
        DARKEN,

        REMIND: cross check this formula with OpenVG spec... The lighter of the color components from the two inputs are selected to produce the resulting color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = max(C_top, C_bot)


Notes:

This mode is commutative (ordering of inputs
does not matter).
This mode is the mathematical opposite of the DARKEN mode. 
/**
         * REMIND: cross check this formula with OpenVG spec...
         *
         * The lighter of the color components from the two inputs are
         * selected to produce the resulting color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = max(<em>C<sub>top</sub></em>, <em>C<sub>bot</sub></em>)
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is commutative (ordering of inputs
         * does not matter).
         * <li>This mode is the mathematical opposite of
         * the {@link #DARKEN} mode.
         * </ul>
         */
        LIGHTEN,

        The bottom input color components are divided by the inverse of the top input color components to produce the resulting color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = C_bot / (1-C_top)

/**
         * The bottom input color components are divided by the inverse
         * of the top input color components to produce the resulting color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = <em>C<sub>bot</sub></em> / (1-<em>C<sub>top</sub></em>)
         * </pre>
         */
        COLOR_DODGE,

        The inverse of the bottom input color components are divided by the top input color components, all of which is then inverted to produce the resulting color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = 1-((1-C_bot) / C_top)

/**
         * The inverse of the bottom input color components are divided by
         * the top input color components, all of which is then inverted
         * to produce the resulting color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = 1-((1-<em>C<sub>bot</sub></em>) / <em>C<sub>top</sub></em>)
         * </pre>
         */
        COLOR_BURN,

        The input color components are either multiplied or screened, depending on the top input color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     REMIND: not sure how to express this succinctly yet...


Notes:

This mode is a combination of SCREEN and MULTIPLY, depending on the top input color. 
This mode is the mathematical opposite of the OVERLAY mode. 
/**
         * The input color components are either multiplied or screened,
         * depending on the top input color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      REMIND: not sure how to express this succinctly yet...
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is a combination of {@link #SCREEN} and
         * {@link #MULTIPLY}, depending on the top input color.
         * <li>This mode is the mathematical opposite of
         * the {@link #OVERLAY} mode.
         * </ul>
         */
        HARD_LIGHT,

        REMIND: this is a complicated formula, TBD...
/**
         * REMIND: this is a complicated formula, TBD...
         */
        SOFT_LIGHT,

        The darker of the color components from the two inputs are subtracted from the lighter ones to produce the resulting color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = abs(C_top-C_bot)


Notes:

This mode is commutative (ordering of inputs
does not matter).
This mode can be used to invert parts of the bottom input
image, or to quickly compare two images (equal pixels will result
in black).
Rendering with a completely white top input inverts the
bottom input; rendering with a completely black top input produces
a result equivalent to the bottom input.

/**
         * The darker of the color components from the two inputs are
         * subtracted from the lighter ones to produce the resulting color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = abs(<em>C<sub>top</sub></em>-<em>C<sub>bot</sub></em>)
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is commutative (ordering of inputs
         * does not matter).
         * <li>This mode can be used to invert parts of the bottom input
         * image, or to quickly compare two images (equal pixels will result
         * in black).
         * <li>Rendering with a completely white top input inverts the
         * bottom input; rendering with a completely black top input produces
         * a result equivalent to the bottom input.
         * </ul>
         */
        DIFFERENCE,

        The color components from the two inputs are multiplied and doubled, and then subtracted from the sum of the bottom input color components, to produce the resulting color. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     C_r = C_top + C_bot - (2*C_top*C_bot)


Notes:

This mode is commutative (ordering of inputs
does not matter).
This mode can be used to invert parts of the bottom input.
This mode produces results that are similar to those of DIFFERENCE, except with lower contrast. 
Rendering with a completely white top input inverts the
bottom input; rendering with a completely black top input produces
a result equivalent to the bottom input.

/**
         * The color components from the two inputs are multiplied and
         * doubled, and then subtracted from the sum of the bottom input
         * color components, to produce the resulting color.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>C<sub>r</sub></em> = <em>C<sub>top</sub></em> + <em>C<sub>bot</sub></em> - (2*<em>C<sub>top</sub></em>*<em>C<sub>bot</sub></em>)
         * </pre>
         * <p>
         * Notes:
         * <ul>
         * <li>This mode is commutative (ordering of inputs
         * does not matter).
         * <li>This mode can be used to invert parts of the bottom input.
         * <li>This mode produces results that are similar to those of
         * {@link #DIFFERENCE}, except with lower contrast.
         * <li>Rendering with a completely white top input inverts the
         * bottom input; rendering with a completely black top input produces
         * a result equivalent to the bottom input.
         * </ul>
         */
        EXCLUSION,

        The red component of the bottom input is replaced with the red component of the top input; the other color components are unaffected. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     R_r = R_top
     G_r = G_bot
     B_r = B_bot

/**
         * The red component of the bottom input is replaced with the
         * red component of the top input; the other color components
         * are unaffected.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>R<sub>r</sub></em> = <em>R<sub>top</sub></em>
         *      <em>G<sub>r</sub></em> = <em>G<sub>bot</sub></em>
         *      <em>B<sub>r</sub></em> = <em>B<sub>bot</sub></em>
         * </pre>
         */
        RED,

        The green component of the bottom input is replaced with the green component of the top input; the other color components are unaffected. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     R_r = R_bot
     G_r = G_top
     B_r = B_bot

/**
         * The green component of the bottom input is replaced with the
         * green component of the top input; the other color components
         * are unaffected.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>R<sub>r</sub></em> = <em>R<sub>bot</sub></em>
         *      <em>G<sub>r</sub></em> = <em>G<sub>top</sub></em>
         *      <em>B<sub>r</sub></em> = <em>B<sub>bot</sub></em>
         * </pre>
         */
        GREEN,

        The blue component of the bottom input is replaced with the blue component of the top input; the other color components are unaffected. The alpha components are blended according to the SRC_OVER equation. 
Thus:
     A_r = A_top + A_bot*(1-A_top)
     R_r = R_bot
     G_r = G_bot
     B_r = B_top

/**
         * The blue component of the bottom input is replaced with the
         * blue component of the top input; the other color components
         * are unaffected.
         * The alpha components are blended according
         * to the {@link #SRC_OVER} equation.
         * <p>
         * Thus:
         * <pre>
         *      <em>A<sub>r</sub></em> = <em>A<sub>top</sub></em> + <em>A<sub>bot</sub></em>*(1-<em>A<sub>top</sub></em>)
         *      <em>R<sub>r</sub></em> = <em>R<sub>bot</sub></em>
         *      <em>G<sub>r</sub></em> = <em>G<sub>bot</sub></em>
         *      <em>B<sub>r</sub></em> = <em>B<sub>top</sub></em>
         * </pre>
         */
        BLUE,
    }

    private Mode mode;
    private float opacity;

    Constructs a new Blend effect with the given mode and the default opacity (1.0). Either or both inputs may be null to indicate that the default input should be used. 
Params: mode – the blending mode
bottomInput – the bottom input
topInput – the top input
Throws: IllegalArgumentException – if mode is null/**
     * Constructs a new {@code Blend} effect with the given mode and the
     * default opacity (1.0).
     * Either or both inputs may be {@code null} to indicate that the default
     * input should be used.
     *
     * @param mode the blending mode
     * @param bottomInput the bottom input
     * @param topInput the top input
     * @throws IllegalArgumentException if {@code mode} is null
     */
    public Blend(Mode mode, Effect bottomInput, Effect topInput) {
        super(bottomInput, topInput);
        setMode(mode);
        setOpacity(1f);
    }

    Returns the bottom input for this Effect. 
Returns: the bottom input for this Effect/**
     * Returns the bottom input for this {@code Effect}.
     *
     * @return the bottom input for this {@code Effect}
     */
    public final Effect getBottomInput() {
        return getInputs().get(0);
    }

    Sets the bottom input for this Effect to a specific Effect or to the default input if input is null. 
Params: bottomInput – the bottom input for this Effect/**
     * Sets the bottom input for this {@code Effect} to a specific
     * {@code Effect} or to the default input if {@code input} is
     * {@code null}.
     *
     * @param bottomInput the bottom input for this {@code Effect}
     */
    public void setBottomInput(Effect bottomInput) {
        setInput(0, bottomInput);
    }

    Returns the top input for this Effect. 
Returns: the top input for this Effect/**
     * Returns the top input for this {@code Effect}.
     *
     * @return the top input for this {@code Effect}
     */
    public final Effect getTopInput() {
        return getInputs().get(1);
    }

    Sets the top input for this Effect to a specific Effect or to the default input if input is null. 
Params: topInput – the top input for this Effect/**
     * Sets the top input for this {@code Effect} to a specific
     * {@code Effect} or to the default input if {@code input} is
     * {@code null}.
     *
     * @param topInput the top input for this {@code Effect}
     */
    public void setTopInput(Effect topInput) {
        setInput(1, topInput);
    }

    Returns the Mode used to blend the two inputs together. 
Returns: the Mode used to blend the two inputs together./**
     * Returns the {@code Mode} used to blend the two inputs together.
     *
     * @return the {@code Mode} used to blend the two inputs together.
     */
    public Mode getMode() {
        return mode;
    }

    Sets the Mode used to blend the two inputs together.       Min: n/a
      Max: n/a
  Default: Mode.SRC_OVER
 Identity: n/a

Params: mode – the blending mode
Throws: IllegalArgumentException – if mode is null/**
     * Sets the {@code Mode} used to blend the two inputs together.
     * <pre>
     *       Min: n/a
     *       Max: n/a
     *   Default: Mode.SRC_OVER
     *  Identity: n/a
     * </pre>
     *
     * @param mode the blending mode
     * @throws IllegalArgumentException if {@code mode} is null
     */
    public void setMode(Mode mode) {
        if (mode == null) {
            throw new IllegalArgumentException("Mode must be non-null");
        }
        Blend.Mode old = this.mode;
        this.mode = mode;
        updatePeerKey("Blend_" + mode.name());
    }

    Returns the opacity value, which is modulated with the top input
prior to blending.
Returns: the opacity value/**
     * Returns the opacity value, which is modulated with the top input
     * prior to blending.
     *
     * @return the opacity value
     */
    public float getOpacity() {
        return opacity;
    }

    Sets the opacity value, which is modulated with the top input prior
to blending.
      Min: 0.0
      Max: 1.0
  Default: 1.0
 Identity: 1.0

Params: opacity – the opacity value
Throws: IllegalArgumentException – if opacity is outside the allowable range/**
     * Sets the opacity value, which is modulated with the top input prior
     * to blending.
     * <pre>
     *       Min: 0.0
     *       Max: 1.0
     *   Default: 1.0
     *  Identity: 1.0
     * </pre>
     *
     * @param opacity the opacity value
     * @throws IllegalArgumentException if {@code opacity} is outside the
     * allowable range
     */
    public void setOpacity(float opacity) {
        if (opacity < 0f || opacity > 1f) {
            throw new IllegalArgumentException("Opacity must be in the range [0,1]");
        }
        float old = this.opacity;
        this.opacity = opacity;
    }

    Transform the specified point p from the coordinate space of the primary content input to the coordinate space of the effect output. In essence, this method asks the question "Which output coordinate is most affected by the data at the specified coordinate in the primary source input?"  The Blend effect delegates this operation to its top input, or the defaultInput if the top input is null. 
Params: p – the point in the coordinate space of the primary content
         input to be transformed
defaultInput – the default input Effect to be used in all cases where a filter has a null input
Returns: the transformed point in the coordinate space of the result/**
     * Transform the specified point {@code p} from the coordinate space
     * of the primary content input to the coordinate space of the effect
     * output.
     * In essence, this method asks the question "Which output coordinate
     * is most affected by the data at the specified coordinate in the
     * primary source input?"
     * <p>
     * The {@code Blend} effect delegates this operation to its {@code top}
     * input, or the {@code defaultInput} if the {@code top} input is
     * {@code null}.
     *
     * @param p the point in the coordinate space of the primary content
     *          input to be transformed
     * @param defaultInput the default input {@code Effect} to be used in
     *                     all cases where a filter has a null input
     * @return the transformed point in the coordinate space of the result
     */
    @Override
    public Point2D transform(Point2D p, Effect defaultInput) {
        return getDefaultedInput(1, defaultInput).transform(p, defaultInput);
    }

    Transform the specified point p from the coordinate space of the output of the effect into the coordinate space of the primary content input. In essence, this method asks the question "Which source coordinate contributes most to the definition of the output at the specified coordinate?"  The Blend effect delegates this operation to its top input, or the defaultInput if the top input is null. 
Params: p – the point in the coordinate space of the result output
         to be transformed
defaultInput – the default input Effect to be used in all cases where a filter has a null input
Returns: the untransformed point in the coordinate space of the
        primary content input/**
     * Transform the specified point {@code p} from the coordinate space
     * of the output of the effect into the coordinate space of the
     * primary content input.
     * In essence, this method asks the question "Which source coordinate
     * contributes most to the definition of the output at the specified
     * coordinate?"
     * <p>
     * The {@code Blend} effect delegates this operation to its {@code top}
     * input, or the {@code defaultInput} if the {@code top} input is
     * {@code null}.
     *
     * @param p the point in the coordinate space of the result output
     *          to be transformed
     * @param defaultInput the default input {@code Effect} to be used in
     *                     all cases where a filter has a null input
     * @return the untransformed point in the coordinate space of the
     *         primary content input
     */
    @Override
    public Point2D untransform(Point2D p, Effect defaultInput) {
        return getDefaultedInput(1, defaultInput).untransform(p, defaultInput);
    }

    @Override
    public RenderState getRenderState(FilterContext fctx,
                                      BaseTransform transform,
                                      Rectangle outputClip,
                                      Object renderHelper,
                                      Effect defaultInput)
    {
        // A blend operation operates on its inputs pixel-by-pixel
        // with no expansion or contraction.
        // RT-27563
        // TODO: The RenderSpaceRenderState object uses the output clip unchanged
        // for its inputs, but we could further restrict the amount we ask for
        // each input to the intersection of the two input bounds, but for now we
        // will simply let it pass along the output clip as the input clip.
        return RenderState.RenderSpaceRenderState;
    }

    @Override
    public boolean reducesOpaquePixels() {
        final Effect bottomInput = getBottomInput();
        final Effect topInput = getTopInput();
        switch (getMode()) {
            case SRC_IN:
            case SRC_OUT:
                return true;
            case SRC_ATOP:
                return bottomInput != null && bottomInput.reducesOpaquePixels();
            case SRC_OVER:
            case ADD:
            case MULTIPLY:
            case SCREEN:
            case OVERLAY:
            case DARKEN:
            case LIGHTEN:
            case COLOR_DODGE:
            case COLOR_BURN:
            case HARD_LIGHT:
            case SOFT_LIGHT:
            case DIFFERENCE:
            case EXCLUSION:
            case RED:
            case GREEN:
            case BLUE:
                return topInput != null && topInput.reducesOpaquePixels() && bottomInput != null && bottomInput.reducesOpaquePixels();
        }
        return true;
    }
}
Params:	mode – the blending mode bottomInput – the bottom input topInput – the top input
Throws:	IllegalArgumentException – if `mode` is null
Params:	mode – the blending mode
Throws:	IllegalArgumentException – if `mode` is null
Params:	opacity – the opacity value
Throws:	IllegalArgumentException – if `opacity` is outside the allowable range
Params:	p – the point in the coordinate space of the primary content input to be transformed defaultInput – the default input `Effect` to be used in all cases where a filter has a null input
Returns:	the transformed point in the coordinate space of the result
/

org.openjfx/ javafx-graphics/ 12/ com/sun/scenario/effect/Blend.java
