<?xml version="1.0"?>
<doc>
    <assembly>
        <name>PaintDotNet.Effects.Core</name>
    </assembly>
    <members>
        <member name="M:PaintDotNet.Effects.BitmapEffect.OnInitializeRenderInfo(PaintDotNet.Effects.IBitmapEffectRenderInfo)">
            <summary>
            Overridden by the derived class to specify rendering information.
            </summary>
            <param name="renderInfo">
            An object that allows the effect to specify its rendering information, such as its output pixel format.
            </param>
        </member>
        <member name="T:PaintDotNet.Effects.BitmapEffectInitializeInfo">
            <summary>
            Allows the effect host to provide initialization information for an effect.
            </summary>
            <remarks>
            This class is currently empty, but may be expanded in the future.
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.BitmapEffectOutputExtensions.Lock``1(PaintDotNet.Effects.IBitmapEffectOutput)">
            <summary>
            <inheritdoc cref="M:PaintDotNet.Effects.IBitmapEffectOutput.Lock(PaintDotNet.Imaging.PixelFormat@)"/>
            </summary>
            <typeparam name="TPixel">The pixel format for the buffer. This must be the same pixel format
            specified with <see cref="P:PaintDotNet.Effects.IBitmapEffectRenderInfo.OutputPixelFormat"/>. If that property was
            not set by the effect, then <see cref="T:PaintDotNet.Imaging.ColorBgra32"/> must be used.</typeparam>
            <remarks>
            You may use the <see cref="M:PaintDotNet.Imaging.BitmapLockExtensions.AsRegionPtr``1(PaintDotNet.Imaging.IBitmapLock{``0})"/> to
            simplify access to the <see cref="T:PaintDotNet.Imaging.IBitmapLock`1"/>
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.BitmapEffectOutputExtensions.LockBgra32(PaintDotNet.Effects.IBitmapEffectOutput)">
            <summary>
            <inheritdoc cref="M:PaintDotNet.Effects.IBitmapEffectOutput.Lock(PaintDotNet.Imaging.PixelFormat@)"/> <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/> is used as the pixel format.
            </summary>
            <remarks>
            You may use the <see cref="M:PaintDotNet.Imaging.BitmapLockExtensions.AsRegionPtr``1(PaintDotNet.Imaging.IBitmapLock{``0})"/> to
            simplify access to the <see cref="T:PaintDotNet.Imaging.IBitmapLock`1"/>
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.SingleThreaded">
            <summary>
            Only one thread will be used for rendering the effect.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.DisableSelectionClipping">
            <summary>
            An effect's rendering is normally clipped (masked) by the active selection. This flag disables that,
            giving the effect access to the entire output buffer. 
            </summary>
            <remarks>
            The selection data provided by Environment.Selection is not affected by this flag.
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.ForceAliasedSelectionQuality">
            <summary>
            The active selection will be rendered without antialiasing, as if the user had chosen pixelated
            selection quality in the toolbar.
            </summary>
            <remarks>
            The selection data provided by Environment.Selection will be pixelated, even if the user
            had not chosen pixelated selection quality in the toolbar.<br/>
            It is recommended to use the DisableSelectionClipping flag instead of this one, which will enable
            access to the full quality selection.
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.FirstTileIsRenderedWithBarrier">
            <summary>
            Enabling this causes the first tile (that is, the first call to Render) to happen in a single-
            threaded manner. No other threads will be activated until after the first Render call completes.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.UninitializedOutputBuffer">
            <summary>
            Enabling this causes the effect system to not zero-fill the output buffer before sending it
            to <see cref="M:PaintDotNet.Effects.BitmapEffect.OnRender(PaintDotNet.Effects.IBitmapEffectOutput)"/>. If the effect implementation always
            sets every output pixel, this can improve performance a little. If the effect does not set
            every output pixel, then the output contents are undefined and there will be rendering artifacts.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingSchedule.None">
            <summary>
            <inheritdoc cref="F:PaintDotNet.Effects.EffectRenderingSchedule.None"/>
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingSchedule.HorizontalStrips">
            <summary>
            <inheritdoc cref="F:PaintDotNet.Effects.EffectRenderingSchedule.SmallHorizontalStrips"/>
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.BitmapEffectRenderingSchedule.SquareTiles">
            <summary>
            The image is broken up into square tiles.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.ClassicEffectBase.Category">
            <summary>
            Returns the category of the effect. If there is no EffectCategoryAttribute
            applied to the runtime type, then the default category, EffectCategory.Effect,
            will be returned.
            </summary>
            <remarks>
            This controls which menu in the user interface the effect is placed in to.
            </remarks>
        </member>
        <member name="T:PaintDotNet.Effects.Effect">
            <summary>
            The base class for &quot;classic&quot; effects.<br/>
            <br/>
            <b>NOTE:</b> It is strongly recommended that you derive from <see cref="T:PaintDotNet.Effects.BitmapEffect"/> instead.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.Effect.#ctor(System.String,PaintDotNet.Imaging.IBitmapSource,System.String,PaintDotNet.Effects.EffectOptions)">
            <summary>
            <inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)"/>
            </summary>
            <param name="name"><inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)" path="/param[@name='name']" /></param>
            <param name="image"><inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)" path="/param[@name='image']" /></param>
            <param name="submenuName"><inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)" path="/param[@name='submenuName']" /></param>
            <param name="options"><inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)" path="/param[@name='options']" /></param>
        </member>
        <member name="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)">
            <summary>
            The constructor for the Effect class.
            </summary>
            <param name="name">The display name of the effect which will be used in UI elements (e.g. menus, dialog titles, history entries).</param>
            <param name="image">
            An image/icon for the effect that will be used in UI elements (e.g. menus, dialog boxes, history entries).<br/>
            This should have a square size, at least 16x16 pixels, and will be scaled up or down to 16x16 dips (e.g. 32x32 pixels if system scaling is set to 200%).
            </param>
            <param name="submenuName">The name of a sub-menu to place the effect into. May be null, in which case no sub-menu is used.</param>
            <param name="options">Contains flags and options to configure the behavior of the effect.</param>
        </member>
        <member name="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.String,PaintDotNet.Effects.EffectOptions)">
            <summary>
            <inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)"/>
            </summary>
            <param name="name"><inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)" path="/param[@name='name']" /></param>
            <param name="submenuName"><inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)" path="/param[@name='submenuName']" /></param>
            <param name="options"><inheritdoc cref="M:PaintDotNet.Effects.Effect.#ctor(System.String,System.Drawing.Image,System.String,PaintDotNet.Effects.EffectOptions)" path="/param[@name='options']" /></param>
        </member>
        <member name="M:PaintDotNet.Effects.Effect.Render(PaintDotNet.Effects.EffectConfigToken,PaintDotNet.RenderArgs,PaintDotNet.RenderArgs,System.Drawing.Rectangle[],System.Int32,System.Int32)">
            <summary>
            Performs the effect's rendering. The source is to be treated as read-only,
            and only the destination pixels within the given rectangle-of-interest are
            to be written to. However, in order to compute the destination pixels,
            any pixels from the source may be utilized.
            </summary>
            <param name="token">The token that contains the parameters to the effect. If IsConfigurable is false, then this will be null.</param>
            <param name="dstArgs">Describes the destination surface.</param>
            <param name="srcArgs">Describes the source surface.</param>
            <param name="rois">The list of rectangles that describes the region to be rendered.</param>
            <param name="startIndex">The index within roi to start enumerating from.</param>
            <param name="length">The number of rectangles to enumerate from roi.</param>
        </member>
        <member name="T:PaintDotNet.Effects.EffectCategory">
            <summary>
            Categories for effects that determine their placement within
            paint.net's menu hierarchy.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectCategory.Effect">
            <summary>
            The default category for an effect. This will place effects in to the "Effects" menu.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectCategory.Adjustment">
            <summary>
            Signifies that this effect should be an "Image Adjustment", placing the effect in
            the "Adjustments" submenu in the "Layers" menu.
            These types of effects are typically quick to execute. They are also preferably 
            "unary" (see EffectTypeHint) but are not required to be.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectCategory.DoNotDisplay">
            <summary>
            Signifies that this effect should not be displayed in any menu.
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.EffectCategoryAttribute">
            <summary>
            Allows you to categorize an Effect to place it in the appropriate menu
            within paint.net.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.EffectConfigDialog.EffectSourceSurface">
            <summary>
            This is the surface that will be used as the source for rendering.
            Its contents will not change for the lifetime of this dialog box
            ("lifetime" being defined as "until Close() is called")
            Treat this object as read-only. In your OnLoad method, feel free
            to do any analysis of this surface to populate the dialog box.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigDialog.OnLoad(System.EventArgs)">
            <summary>
            Overrides Form.OnLoad.
            </summary>
            <param name="e"></param>
            <remarks>
            Derived classes MUST call this base method if they override it!
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigDialog.InitialInitToken">
            <summary>
            This method must be overriden in the derived classes.
            In this you initialize the default values for the token, and
            thus the default values for the dialog box.
            The job of this function is to initialize this.theEffectToken with
            a non-null reference.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigDialog.InitDialogFromToken(PaintDotNet.Effects.EffectConfigToken)">
            <summary>
            This method must be overridden in derived classes.
            In this method you must take the values from the given EffectToken
            and use them to properly initialize the dialog's user interface elements.
            Make sure to read values from the passed-in effectToken
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigDialog.InitTokenFromDialog">
            <summary>
            This method must be overridden in derived classes.
            In this method you must take the values from the dialog box
            and use them to properly initialize theEffectToken.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigForm.OnLoad(System.EventArgs)">
            <summary>
            <inheritdoc />
            </summary>
            <remarks>
            This method is sealed. To handle the <see cref="E:System.Windows.Forms.Form.Load"/> event, override the parameterless <see cref="M:PaintDotNet.Effects.EffectConfigForm.OnLoading"/>
            or <see cref="M:PaintDotNet.Effects.EffectConfigForm.OnLoaded"/> methods instead.<br/>
            <br/>
            This method performs the following in this order:<br/>
            <list type="number">
              <item><see cref="M:PaintDotNet.Effects.EffectConfigForm.OnLoading"/></item>
              <item>The base class's <see cref="M:System.Windows.Forms.Form.OnLoad(System.EventArgs)"/> is then called, which raises the <see cref="E:System.Windows.Forms.Form.Load"/> event.</item>
              <item><see cref="M:PaintDotNet.Effects.EffectConfigForm.UpdateDialogFromToken"/></item>
              <item><see cref="M:PaintDotNet.Effects.EffectConfigForm.UpdateTokenFromDialog"/></item>
              <item><see cref="M:PaintDotNet.Effects.EffectConfigForm.OnLoaded"/></item>
            </list>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.EffectConfigForm.Token">
            <summary>
            Gets or sets the token that it passed to the effect to configure its rendering parameters.
            </summary>
        </member>
        <member name="E:PaintDotNet.Effects.EffectConfigForm.TokenChanged">
            <summary>
            Occurs when the <see cref="P:PaintDotNet.Effects.EffectConfigForm.Token"/> property is set or modified.
            </summary>
            <remarks>
            To cause the token to be synchronized with the dialog's controls, call <see cref="M:PaintDotNet.Effects.EffectConfigForm.UpdateTokenFromDialog"/>.
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigForm.OnTokenChanged">
            <summary>
            Raises the <see cref="E:PaintDotNet.Effects.EffectConfigForm.TokenChanged"/> event.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigForm.OnCreateInitialToken">
            <summary>
            Implemented by the derived class to create the initial token at construction time. The token
            is usually populated with the default values for the effect.<br/>
            This method is called before the derived class's constructor, and before the <see cref="P:PaintDotNet.Effects.EffectConfigForm.Effect"/>
            property has been set.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigForm.UpdateTokenFromDialog">
            <summary>
            Called by the derived class to indicate that the <see cref="P:PaintDotNet.Effects.EffectConfigForm.Token"/> should be updated,
            usually in response to changes the user has made to the dialog's controls (e.g. sliders,
            checkboxes, etc.).<br/>
            This will result in a call to the <see cref="M:PaintDotNet.Effects.EffectConfigForm.OnUpdateTokenFromDialog(PaintDotNet.Effects.EffectConfigToken)"/> method, followed by a
            call to <see cref="M:PaintDotNet.Effects.EffectConfigForm.OnTokenChanged"/> which will raise the <see cref="E:PaintDotNet.Effects.EffectConfigForm.TokenChanged"/>
            event.<br/>
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigForm.OnUpdateTokenFromDialog(PaintDotNet.Effects.EffectConfigToken)">
            <summary>
            Called when the <see cref="P:PaintDotNet.Effects.EffectConfigForm.Token"/> should be synchronized with the dialog's controls.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigForm.UpdateDialogFromToken">
            <summary>
            Called by the derived class to indicate that the <see cref="P:PaintDotNet.Effects.EffectConfigForm.Token"/> has been modified,
            and the dialog should be synchronized with it.<br/>
            It is not necessary to call this method if you set the <see cref="P:PaintDotNet.Effects.EffectConfigForm.Token"/> property;
            it is only necessary when modifying the token in-place.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigForm.OnUpdateDialogFromToken(PaintDotNet.Effects.EffectConfigToken)">
            <summary>
            This method must be overridden in derived classes. Use the data from the given token object
            to initialize or update the dialog's UI.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectConfigToken.Clone">
            <summary>
            This should simply call "new myType(this)" ... do not call the base
            implementation of Clone, as this is handled by the constructors.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectDocumentInfoExtensions.GetBitmap``1(PaintDotNet.Effects.IEffectDocumentInfo)">
            <summary>
            <inheritdoc cref="M:PaintDotNet.Effects.IEffectDocumentInfo.GetBitmap(PaintDotNet.Imaging.PixelFormat@)"/>
            </summary>
            <typeparam name="TPixel">
            The requested pixel struct for the bitmap. The native pixel struct used by Paint.NET is
            currently <see cref="T:PaintDotNet.Imaging.ColorBgra32"/>, which corresponds to the <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/>
            pixel format. Specifying a different pixel struct/format is valid, but will incur conversion
            overhead.
            </typeparam>
            <param name="document">The document.</param>
            <returns>The bitmap.</returns>
        </member>
        <member name="M:PaintDotNet.Effects.EffectDocumentInfoExtensions.GetBitmapBgra32(PaintDotNet.Effects.IEffectDocumentInfo)">
            <summary>
            <b>Recommended overload.</b> Gets a bitmap that renders the document in the native Bgra32 pixel format.
            This is the full composition of the document, including all of the layers with their rendering
            properties applied (blend mode, opacity, and visibility).
            </summary>
            <param name="document">The document.</param>
            <returns>The bitmap.</returns>
        </member>
        <member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.CloneWithNewSource(PaintDotNet.Effects.IEffectEnvironment,PaintDotNet.Imaging.IBitmapSource)">
            <summary>
            Creates a copy of the environment while replacing the source bitmap's layer. Other data is
            unaffected, including the document's bitmap. This method can be used when chaining effects that are instantiated with
            <see cref="T:PaintDotNet.Effects.IEffectsService2"/>.
            </summary>
            <param name="environment">The environment.</param>
            <param name="newSourceBitmap">The new bitmap to use as the source layer bitmap.</param>
            <returns>The new environment.</returns>
        </member>
        <member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.GetSourceBitmap(PaintDotNet.Effects.IEffectEnvironment,PaintDotNet.Imaging.PixelFormat@)">
            <summary>
            Gets a bitmap that renders the source layer's contents in the requested pixel format.
            </summary>
            <param name="environment">The effect environment.</param>
            <param name="pixelFormat"><inheritdoc cref="M:PaintDotNet.Effects.IEffectLayerInfo.GetBitmap(PaintDotNet.Imaging.PixelFormat@)"/> </param>
            <returns><inheritdoc cref="M:PaintDotNet.Effects.IEffectLayerInfo.GetBitmap(PaintDotNet.Imaging.PixelFormat@)"/></returns>
            <remarks>
            This method is equivalent to calling:
            <code>this.Environment.Document.Layers[this.Environment.SourceLayerIndex].GetSourceBitmap(pixelFormat)</code>
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.GetSourceBitmap``1(PaintDotNet.Effects.IEffectEnvironment)">
            <summary>
            <inheritdoc cref="M:PaintDotNet.Effects.EffectEnvironmentExtensions.GetSourceBitmap(PaintDotNet.Effects.IEffectEnvironment,PaintDotNet.Imaging.PixelFormat@)"/>
            </summary>
            <typeparam name="TPixel">
            The requested pixel struct for the bitmap. The native pixel struct used by Paint.NET is
            currently <see cref="T:PaintDotNet.Imaging.ColorBgra32"/>, which corresponds to the <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/>
            pixel format. Specifying a different pixel struct/format is valid, but will incur conversion
            overhead.
            </typeparam>
            <param name="environment">The environment.</param>
            <returns>The bitmap.</returns>
            <remarks>
            This method is equivalent to calling:
            <code>this.Environment.Document.Layers[this.Environment.SourceLayerIndex].GetSourceBitmap&lt;TPixel&gt;()</code>
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.GetSourceBitmapBgra32(PaintDotNet.Effects.IEffectEnvironment)">
            <summary>
            <b>(Recommended)</b> Gets a bitmap that renders the source layer's contents in the native Bgra32 pixel format.
            </summary>
            <param name="environment">The environment.</param>
            <returns>The bitmap.</returns>
            <remarks>
            This method is equivalent to calling:
            <code>this.Environment.Document.Layers[this.Environment.SourceLayerIndex].GetSourceBitmapBgra32()</code>
            </remarks>    
        </member>
        <member name="M:PaintDotNet.Effects.EffectEnvironmentParameters.GetSelectionAsScans">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.IEffectSelectionInfo.RenderScans" />
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectEnvironmentParameters.CloneWithDifferentSourceSurface(PaintDotNet.Surface)">
            <summary>
            Use this if you are implementing an Effect that needs to chain together other Effects which will
            need the same environment parameters but which will be reading from a different source Surface.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectEnvironmentParameters.GetSelection(System.Drawing.Rectangle)">
            <summary>
            Gets the user's currently selected area.
            </summary>
            <param name="boundingRect">
            The bounding rectangle of the surface you will be rendering to. 
            The region returned will be clipped to this bounding rectangle.
            </param>
            <remarks>
            Note that calls to Render() will already be clipped to this selection area. 
            This data is only useful when an effect wants to change its rendering based
            on what the user has selected. For instance, This is used by Auto-Levels to
            only calculate new levels based on what the user has selected
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectFlags.None">
            <summary>
            The effect is not configurable and has no UI.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectFlags.Configurable">
            <summary>
            The effect is configurable, so it will display UI with an EffectConfigDialog and store its configuration
            properties using an EffectConfigToken.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectFlags.FirstTileIsNotRenderedWithBarrier">
            <summary>
            Normally an effect's first tile (that is, the first call to Render) is rendered by itself, after
            which the remaining tiles are rendered in parallel with full multithreading.<br/>
            With this flag, the first tile is not special and will be rendered in parallel along with all the
            other tiles.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectFlags.ForceAliasedSelectionQuality">
            <summary>
            The active selection will be rendered without antialiasing, as if the user had chosen pixelated
            selection quality in the toolbar.
            </summary>
            <remarks>
            The selection data provided by Environment.Selection will be pixelated, even if the user
            had not chosen pixelated selection quality in the toolbar.<br/>
            It is recommended to use the DisableSelectionClipping flag instead of this one, which will enable
            access to the full quality selection.
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectFlags.SingleThreaded">
            <summary>
            Only one thread will be used for rendering the effect.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.EffectLayerInfoExtensions.GetBitmap``1(PaintDotNet.Effects.IEffectLayerInfo)">
            <summary>
            <inheritdoc cref="M:PaintDotNet.Effects.IEffectLayerInfo.GetBitmap(PaintDotNet.Imaging.PixelFormat@)"/>
            </summary>
            <typeparam name="TPixel">
            The requested pixel struct for the bitmap. The native pixel struct used by Paint.NET is
            currently <see cref="T:PaintDotNet.Imaging.ColorBgra32"/>, which corresponds to the <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/>
            pixel format. Specifying a different pixel struct/format is valid, but will incur conversion
            overhead.
            </typeparam>
            <param name="layer">The layer.</param>
            <returns>The bitmap.</returns>
        </member>
        <member name="M:PaintDotNet.Effects.EffectLayerInfoExtensions.GetBitmapBgra32(PaintDotNet.Effects.IEffectLayerInfo)">
            <summary>
            <b>(Recommended)</b> Gets a bitmap that renders the layer's contents in the native Bgra32 pixel format.
            </summary>
            <param name="layer">The layer.</param>
            <returns>The bitmap.</returns>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.DefaultTilesForCpuRendering">
            <summary>
            The image is broken up into square tiles, the size of which is chosen automatically.
            Each call to Render() contains the scans for 1 tile.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.DefaultTilesForGpuRendering">
            <summary>
            The image is broken up into square tiles, the size of which is chosen automatically.
            Each call to Render() contains the scans for 1 tile.
            </summary>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.SmallHorizontalStrips">
            <summary>
            The image is broken up into small horizontal strips that cover the full width of the image.
            </summary>
            <remarks>
            This is the "classic" rendering schedule up through version 4.0.21. It can be useful for effects
            whose rendering code is most optimal when dealing with full horizontal extents.
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.None">
            <summary>
            There is only one call to the Effect's Render method, and all regions of interest (scans) are
            delivered at that time. This also means rendering is effectively single threaded.
            </summary>
            <remarks>
            This is the same behavior as the now-obsolete EffectFlags.SingleRenderCall.
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.Tiles128x128">
            <summary>
            The image is broken up into 128x128 tiles.
            Each call to Render() contains the scans for 1 tile.
            </summary>
            <remarks>
            This generally works best for classic effects with the 4.0 rendering engine which is based on
            rendering 128x128 tiles. It is also appropriate for GPU/Direct2D effects on very small images
            (less than 1024x1024 pixels).
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.Tiles256x256">
            <summary>
            The image is broken up into 256x256 tiles.
            Each call to Render() contains the scans for 1 tile.
            </summary>
            <remarks>
            This is a good size for GPU/Direct2D effects on small-to-medium sized images (1024x1024 pixels
            or more).
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.Tiles512x512">
            <summary>
            The image is broken up into 512x512 tiles.
            Each call to Render() contains the scans for 1 tile.
            </summary>
            <remarks>
            This is a good size for GPU/Direct2D effects on medium-to-large sized images (2048x2048 pixels
            or more).
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.Tiles1024x1024">
            <summary>
            The image is broken up into 1024x1024 tiles.
            Each call to Render() contains the scans for 1 tile.
            </summary>
            <remarks>
            This is a good size for GPU/Direct2D effects on large sized images (4096x4096 pixels or more).
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.Tiles2048x2048">
            <summary>
            The image is broken up into 2048x2048 tiles.
            Each call to Render() contains the scans for 1 tile.
            </summary>
            <remarks>
            This is a good size for GPU/Direct2D effects on very large sized images (8192x8192 pixels or more).
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.EffectRenderingSchedule.Tiles4096x4096">
            <summary>
            The image is broken up into 4096x4096 tiles.
            Each call to Render() contains the scans for 1 tile.
            </summary>
            <remarks>
            This is a good size for GPU/Direct2D effects on extremely large sized images (16384x16384 pixels or more).
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.EffectSelectionInfo.PaintDotNet#Effects#IEffectSelectionInfo#GeometryList">
            <summary>
            Gets the selection geometry. This is the selection that the user drew, or the pixelated version
            of it if aliased selections are chosen in the toolbar. The geometry will be clipped to the image
            canvas; any portion outside of the image will not be included in this. 
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.EffectSelectionInfo.RenderBounds">
            <summary>
            Gets the bounding rectangle for rendering region. This surrounds all pixels that are affected
            by the selection in the destination surface.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.EffectSelectionInfo.RenderRegionLegacy">
            <summary>
            Gets the region that is affected by the selection in the legacy format (compatible with System.Drawing.Region).
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.Effect`1">
            <summary>
            The base class for &quot;classic&quot; effects with a strongly-typed <see cref="T:PaintDotNet.Effects.EffectConfigToken"/>.<br/>
            <br/>
            <b>NOTE:</b> It is strongly recommended that you derive from <see cref="T:PaintDotNet.Effects.BitmapEffect`1"/> instead.
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.GpuDrawingEffect">
            <summary>
            The base class for Direct2D GPU effects that use drawing commands (e.g. DrawBitmap, FillRectangle).
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.GpuEffect">
            <summary>
            The base class for Direct2D GPU effects. This class is for advanced scenarios.
            You should probably derive from GpuImageEffect/PropertyBasedGpuImageEffect or
            GpuDrawingEffect/PropertyBasedGpuDrawingEffect.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffect.UnPremultiplyOutputIsHandledByDerivedClass">
            <summary>
            Specifies whether the derived class will do the work of unpremultiplying the output based
            on the value of Options.UnPremultiplyOutput. This is only relevant if Options.UnPremultiplyOutput
            is true.
            
            The derived class must still honor the value of Options.UnPremultiplyOutput. It's valid for
            Options.UnPremultiplyOutput to be false and UnPremultiplyOutputIsHandledByDerivedClass to be true,
            in which case unpremultiplication will not be performed.
            
            Because the base GpuEffect class performs unpremultiplication using a separate DrawImage() call
            from the rendering buffer, it can be advantageous for a derived class to do this itself if it can
            combine its effect graph with an UnPremultiplyEffect. This can enable the benefits of shader linking
            and reduce the number of rendering passes by 1.
            
            This isn't really intended for concrete effects that perform their own unpremultiplication, such as
            RadialBlurGpuEffect. For that, Options.UnPremultiplyOutput should just be set to false. Rather, this
            property is intended for abstract classes, such as GpuImageEffect, which are then further derived
            from in order to then implement concrete effects (such as GaussianBlurGpuEffect). This permits 
            retaining the value of Options.UnPremultiplyOutput while shifting the burden of implementing it.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.Gpu.GpuEffect.OnInvalidateDeviceResources">
            <summary>
            This method can be used to Dispose() any resources created from the device context.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.Gpu.GpuEffect.OnSetDeviceContext(PaintDotNet.Direct2D1.IDeviceContext)">
            <summary>
            This method is called when the device context is initialized or recreated.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.Gpu.GpuEffect.OnBeforeDraw(PaintDotNet.Direct2D1.IDeviceContext2,PaintDotNet.Rendering.RectInt32)">
            <summary>
            This method is called once for each tile that is rendered. The renderRect is the
            bounding box for the clipRect(s) that will be passed to OnDraw().
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.Gpu.GpuEffect.OnDraw(PaintDotNet.Direct2D1.IDeviceContext,PaintDotNet.Rendering.RectInt32)">
            <summary>
            This method is called to render a portion of the output. You may use the clipRect
            to optimize your drawing calls.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.Gpu.GpuEffect.OnAfterDraw(PaintDotNet.Direct2D1.IDeviceContext2,PaintDotNet.Rendering.RectInt32)">
            <summary>
            This method is called once after all calls to OnDraw() for a given tile have finished.
            The renderRect parameter will be equal to the one passed to OnBeforeDraw().
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.GpuEffectColorContext">
            <summary>
            Secifies the color space that a <see cref="T:PaintDotNet.Effects.Gpu.GpuEffect"/> performs its rendering in.
            Input images will be converted from their working space to this color space, and
            the output of the effect will then be converted back to the working space of the
            source image.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.WorkingSpaceLinear">
            <summary>
            Gets a color context that matches the source image and which has been converted to use linear (1.0) gamma.
            </summary>
            <remarks>
            This is the recommended color context for most purposes. For more information on linear gamma, see
            articles such as:<br/>
            <a href="https://developer.nvidia.com/gpugems/gpugems3/part-iv-image-effects/chapter-24-importance-being-linear">GPU Gems 3, Chapter 24: The Importance of Being Linear</a><br/>
            <a href="http://www.ericbrasseur.org/gamma.html">Gamma error in picture scaling (Eric Brasseur)</a><br/>
            <br/>
            This will use the source image's color profile and convert it to the linearized version of that color
            profile. For example, sRGB will be converted to scRGB. If the color profile is already linearized, then
            this is equivalent to <see cref="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.WorkingSpace"/>.<br/>
            <br/>
            Some Direct2D effects have an InputGamma property that defaults to sRGB. When using linear gamma you
            should make sure to set this property to Linear.<br/>
            <br/>
            If you need predefined color values (e.g. red, blue, etc.) use the <see cref="T:PaintDotNet.Imaging.LinearColors"/> class.<br/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.WorkingSpace">
            <summary>
            Gets a color context that matches the source image, which results in no color space conversion. Only
            precision and pixel format conversion will be performed. For example, Bgra32 will be converted to
            Rgba128Float by dividing each color component by 255.0f and swizzling from BGR to RGB order. Gamma
            is unchanged.
            </summary>
            <remarks>
            This color context permits you to work with the original pixel data with the highest level of accuracy,
            but with the added cost of complexity or loss of correctness. The image may be encoded in any color
            space or gamma, and you will need to accommodate that, or be implementing an effect where this is not
            a concern.<br/>
            <br/>
            Using this color context is generally not recommended unless you know what you're doing with respect
            to color management, or if you require access to the raw pixel values no matter what, or if you will
            not be doing any sort of blending, antialiasing, sampling, or filtering.
            <br/>
            The color context of the source image is accessible via <see cref="P:PaintDotNet.Effects.Gpu.IGpuEffectImage.ColorContext"/>.<br/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.Srgb">
            <summary>
            Gets a color context that specifies the sRGB color space, which uses a gamma value of approximately 2.2.
            </summary>
            <remarks>
            Compared to <see cref="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.WorkingSpaceLinear"/>, this color context may be more familiar or comfortable
            if you are accustomed to working with 32-bit BGRA/RGBA pixel data, which is always stored as sRGB.
            However, operations on color values, such as blending, sampling, antialiasing, and filtering, will
            not preserve perceptual luminance. Colors will generally end up darker than they should.<br/>
            <br/>
            If you need predefined color values (e.g. red, blue, etc.), use the <see cref="T:PaintDotNet.Imaging.SrgbColors"/> class.<br/>
            <br/>
            Most images are stored as sRGB, which means that most of the time using this color context is
            equivalent to using <see cref="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.WorkingSpace"/>. However, if an image is not stored as sRGB, this
            color context will convert it to sRGB. This may result in precision loss and gamut clipping.<br/>
            <br/>
            For more information, see: <a href="https://en.wikipedia.org/wiki/SRGB">sRGB - Wikipedia</a>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.ScRgb">
            <summary>
            Gets a color context that specifies the scRGB color space, which is the linear gamma, wide gamut
            expansion of sRGB.
            </summary>
            <remarks>
            For more information, see: <a href="https://en.wikipedia.org/wiki/ScRGB">scRGB - Wikipedia</a>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectRenderInfo.Flags">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.Flags"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.Flags"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectRenderInfo.ColorContext">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.ColorContext"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.ColorContext"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectRenderInfo.InputAlphaMode">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.InputAlphaMode"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.InputAlphaMode"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectRenderInfo.OutputAlphaMode">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.OutputAlphaMode"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.OutputAlphaMode"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectRenderInfo.EffectBufferPrecision">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.EffectBufferPrecision"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.EffectBufferPrecision"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.GpuEffectRenderInfo.InputBufferPrecision">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.InputBufferPrecision"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.InputBufferPrecision"/>
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.Gpu.GpuEffectRenderingFlags.DisableSelectionClipping">
            <summary>
            <inheritdoc cref="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.DisableSelectionClipping"/>
            </summary>
            <remarks>
            <inheritdoc cref="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.DisableSelectionClipping"/>
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.Gpu.GpuEffectRenderingFlags.ForceAliasedSelectionQuality">
            <summary>
            <inheritdoc cref="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.ForceAliasedSelectionQuality"/>
            </summary>
            <remarks>
            <inheritdoc cref="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.ForceAliasedSelectionQuality"/>
            </remarks>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.GpuImageEffect">
            <summary>
            The base class for Direct2D GPU effects that are based on Direct2D's imaging/effects system.
            For effects that want to be based on drawing commands (e.g. DrawBitmap, FillRectangle),
            GpuDrawingEffect (or PropertyBasedGpuDrawingEffect) is probably the right choice instead of
            this class.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.Gpu.GpuImageEffect.OnCreateOutput(PaintDotNet.Direct2D1.IDeviceContext)">
            <summary>
            Creates and returns the IDeviceImage that will be used for rendering.
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.GpuImageEffect`1">
            <summary>
            The base class for Direct2D GPU effects. This class is for advanced scenarios.
            You should probably derive from GpuImageEffect/PropertyBasedGpuImageEffect or
            GpuDrawingEffect/PropertyBasedGpuDrawingEffect.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectDocumentInfo.Image">
            <summary>
            Gets an image that renders the document for use with Direct2D. This is the full composition
            of the document, including all of the layers with their rendering properties applied (blend
            mode, opacity, and visibility).
            </summary>
            <remarks>
            You should only retrieve this image if it will actually be used for rendering, as it will
            consume GPU memory once initialized.
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectDocumentInfo2.Layers">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectDocumentInfo.Layers" />
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectDocumentInfo.Layers" />
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectDocumentInfo2.Image">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectDocumentInfo.Image" />
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectDocumentInfo.Image" />
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.SourceImage">
            <summary>
            Gets the source image to use with Direct2D.
            </summary>
            <remarks>
            You should only retrieve this image if it will actually be used for rendering, as it will
            consume GPU memory once initialized.<br/>
            <br/>
            This is equivalent to: <code>this.Environment.Document.Layers[this.Environment.SourceLayerIndex].Image</code>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment2.Selection">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.Selection"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.Selection"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment2.Document">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.Document"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.Document"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment2.SourceImage">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.SourceImage"/>
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.SourceImage"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectImage.ColorContext">
            <summary>
            Gets the color context information associated with the image, if any.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectImage.AlphaMode">
            <summary>
            Gets the alpha mode of the image.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectLayerInfo.Image">
            <summary>
            Gets an image that renders the layer's contents for use with Direct2D.
            </summary>
            <remarks>
            This image does not take <see cref="P:PaintDotNet.Effects.IEffectLayerInfo.Visible"/> or <see cref="P:PaintDotNet.Effects.IEffectLayerInfo.Opacity"/>
            into account.<br/>
            <br/>
            You should only retrieve this image if it will actually be used for rendering, as it will
            consume GPU memory once initialized.
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectLayerInfo2.Image">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectLayerInfo.Image" />
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectLayerInfo.Image" />
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.Flags">
            <summary>
            Specifies flags that can be used to change various aspects of how the effect renders, or
            how it interacts with the effect host.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.ColorContext">
            <summary>
            Specifies the color space that the effect performs its rendering in. Input images retrieved
            through <see cref="T:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment"/> will be converted into this color space, as will
            images created with IDeviceContext.CreateImageFromBitmap(). The effect's output will then
            be converted back to the working space of the destination image.
            </summary>
            <remarks>
            The default value is <see cref="P:PaintDotNet.Effects.Gpu.GpuEffectColorContext.WorkingSpaceLinear"/>.
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.InputAlphaMode">
            <summary>
            Specifies the alpha mode for the <see cref="T:PaintDotNet.Direct2D1.IDeviceImage"/>s retrieved through the
            <see cref="T:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment"/>. When an input bitmap is loaded for use on the GPU as an
            <see cref="T:PaintDotNet.Direct2D1.IDeviceImage"/>, it will be converted to the specified alpha mode if necessary.
            </summary>
            <remarks>
            The default value is <see cref="F:PaintDotNet.Effects.Gpu.GpuEffectAlphaMode.Premultiplied"/>, which is almost always the
            right choice because Direct2D operates natively in premultiplied alpha space. Some advanced
            rendering scenarios may benefit from setting this to <see cref="F:PaintDotNet.Effects.Gpu.GpuEffectAlphaMode.Straight"/>,
            such as when it is important to preserve color values for transparent pixels, or if you are
            using a custom pixel shader that operates on straight alpha.<br/>
            <br/>
            Usually it is best to use the default value (Premultiplied), and to then use <see cref="T:PaintDotNet.Direct2D1.Effects.PremultiplyEffect"/>,
            <see cref="T:PaintDotNet.Direct2D1.Effects.UnPremultiplyEffect"/>, or <see cref="T:PaintDotNet.Direct2D1.Effects.ConvertAlphaEffect"/> to convert the alpha
            mode as required for each effect in the effect graph. This is important when different
            effects or pixel shaders expect different alpha modes. Many effects have an AlphaMode property
            which lets you specify the alpha mode for that effect's inputs and outputs. If an effect does
            not specify anything about its alpha mode, you can assume it uses premultiplied alpha.<br/>
            <br/>
            Paint.NET always uses straight alpha for storage, and Direct2D always uses premultiplied alpha
            for rendering, blending, and compositing. Some Direct2D effects can operate on straight alpha
            and will have documentation saying this, and/or they will have an AlphaMode property to configure
            this. Premultiplied alpha makes many calculations easier, especially for blending and compositing,
            but straight alpha is generally easier to reason about when doing other types of calculations
            (such as in a custom pixel shader).<br/>
            <br/>
            For more information on alpha formats and compositing, see: <a href="https://en.wikipedia.org/wiki/Alpha_compositing">Alpha compositing (Wikipedia)</a>.
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.OutputAlphaMode">
            <summary>
            Specifies the alpha mode of the output. This allows the effect infrastructure to automatically
            convert the effect's output to the alpha mode that is required for storage or rendering.
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.InputAlphaMode"/>
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.EffectBufferPrecision">
            <summary>
            Specifies a value for <see cref="P:PaintDotNet.Direct2D1.IDeviceContext.EffectBufferPrecision"/> that will be set whenever the device context
            is created. If this is null, the property will not be set.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.InputBufferPrecision">
            <summary>
            Specifies the buffer precision for the input images (layers, document, selection mask). This does not affect the memory
            consumed by the backing storage for the image, but does affect precision and quality of premultiplication, and also
            establishes the default precision for any effects it is plugged into (unless overridden by the effect's BufferPrecision
            property).
            </summary>
            <remarks>
            This is similar to setting the BufferPrecision property on an <see cref="T:PaintDotNet.Direct2D1.IDeviceEffect"/>.
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectRenderInfo.DeviceContextParameters">
            <summary>
            Specifies the parameters for creating the <see cref="T:PaintDotNet.Direct2D1.IDeviceContext"/>.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectSelectionInfo.MaskImage">
            <summary>
            Gets an image that renders a mask based on the selection's geometry.
            </summary>
            <remarks>
            The mask image is created on-demand (lazily) and is cached on the GPU. It is important to only call
            this method if you actually intend to use the mask image for rendering. Otherwise, GPU memory usage
            will be higher than necessary which may affect performance.<br/>
            If you need basic information about the selection or mask, use the other methods and properties on
            <see cref="T:PaintDotNet.Effects.IEffectSelectionInfo"/>.
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.Gpu.IGpuEffectSelectionInfo2.MaskImage">
            <summary>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectSelectionInfo.MaskImage" />
            </summary>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.Gpu.IGpuEffectSelectionInfo.MaskImage" />
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.Gpu.InspectTokenAction.None">
            <summary>
            If this value is returned from OnInspectTokenChanges(), the output image created by
            OnCreateOutput() will be retained. OnUpdateOutput() will not be called, and then the
            output image will be rendered using IDeviceContext.DrawImage().
            </summary>
            <remarks>
            This value is useful if you can safely determine that the changes to the token do not
            actually affect the output image.
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.Gpu.InspectTokenAction.RecreateOutput">
            <summary>
            If this value is returned from OnInspectTokenChanges(), the output image created by
            OnCreateOutput() will be disposed.<br/>
            <br/>
            Then, both OnCreateOutput() and OnUpdateOutput() will be called, and then the output
            image will be rendered using IDeviceContext.DrawImage().
            </summary>
            <remarks>
            If this value is always returned from OnInspectTokenChanges() then there is no need
            to implement OnUpdateOutput(). This affords a much simpler programming model, but
            not the best performance.<br/>
            <br/>
            It is always safe to return this value from OnInspectTokenChanges().
            </remarks>
        </member>
        <member name="F:PaintDotNet.Effects.Gpu.InspectTokenAction.UpdateOutput">
            <summary>
            If this value is returned from OnInspectTokenChanges(), the output image created by
            the earlier call to OnCreateOutput() will be retained. OnCreateOutput() will not be
            called again.<br/>
            <br/>
            Then, OnUpdateOutput() will be called, and then the output image will be rendered
            using IDeviceContext.DrawImage().
            </summary>
            <remarks>
            Using this value can be significantly faster than RecreateOutput in scenarios where
            creating the output image is expensive (that is, OnCreateOutput() is expensive, or if
            the output has internal caching). However, it can be difficult -- sometimes
            significantly -- to correctly implement OnUpdateOutput(). Therefore, using this value
            is recommended only for experienced developers who are seeking maximum performance.
            </remarks>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.PropertyBasedGpuDrawingEffect">
            <summary>
            The base class for Direct2D GPU effects that use drawing commands (e.g. DrawBitmap, FillRectangle)
            and that also use IndirectUI.
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.PropertyBasedGpuEffect">
            <summary>
            The base class for Direct2D GPU effects that use IndirectUI. This class is for
            very advanced scenarios.
            You should probably derive from GpuImageEffect, PropertyBasedGpuImageEffect, 
            GpuDrawingEffect, or PropertyBasedGpuDrawingEffect.
            </summary>
        </member>
        <member name="T:PaintDotNet.Effects.Gpu.PropertyBasedGpuImageEffect">
            <summary>
            The base class for Direct2D GPU effects that are based on Direct2D's imaging/effects system
            and that also use IndirectUI.
            For effects that want to be based on drawing commands (e.g. DrawBitmap, FillRectangle),
            GpuDrawingEffect or PropertyBasedGpuDrawingEffect is probably the right choice instead of
            this class.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IBitmapEffectOutput.Bounds">
            <summary>
            Gets the region that needs to be rendered. The buffer returned from the <see cref="M:PaintDotNet.Effects.IBitmapEffectOutput.Lock(PaintDotNet.Imaging.PixelFormat@)"/>
            method will have the same size as this rectangle.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IBitmapEffectOutput.PixelFormat">
            <summary>
            Gets the pixel format of the output buffer. This must match the pixel format when calling
            the <see cref="M:PaintDotNet.Effects.IBitmapEffectOutput.Lock(PaintDotNet.Imaging.PixelFormat@)"/> method.
            </summary>
            <remarks>
            The pixel format for the output buffer is established by setting the <see cref="P:PaintDotNet.Effects.IBitmapEffectRenderInfo.OutputPixelFormat"/>
            property during the <see cref="M:PaintDotNet.Effects.BitmapEffect.OnInitializeRenderInfo(PaintDotNet.Effects.IBitmapEffectRenderInfo)"/> method.
            If the property is not set then the pixel format defaults to <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/>.
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.IBitmapEffectOutput.Lock(PaintDotNet.Imaging.PixelFormat@)">
            <summary>
            Gets the buffer for writing the effect's output to. The origin of the buffer (that is, x=0 y=0)
            corresponds to the <see cref="P:PaintDotNet.Effects.IBitmapEffectOutput.Bounds"/>'s <see cref="P:PaintDotNet.Rendering.RectInt32.Location"/> property.
            </summary>
            <param name="pixelFormat">The pixel format for the buffer. This must be the same pixel format
            specified for the <see cref="P:PaintDotNet.Effects.IBitmapEffectOutput.PixelFormat"/> property.</param>
            <returns>
            The buffer for the effect's output. This buffer is only valid during the effect's render method.
            </returns>
            <remarks>
            <inheritdoc cref="P:PaintDotNet.Effects.IBitmapEffectOutput.PixelFormat"/><br/>
            <br/>
            It is recommended that you use the <see cref="M:PaintDotNet.Effects.BitmapEffectOutputExtensions.Lock``1(PaintDotNet.Effects.IBitmapEffectOutput)"/>
            or <see cref="M:PaintDotNet.Effects.BitmapEffectOutputExtensions.LockBgra32(PaintDotNet.Effects.IBitmapEffectOutput)"/> extension methods
            in order to get a strongly-typed <see cref="T:PaintDotNet.Imaging.IBitmapLock`1"/>. You can then use the
            <see cref="M:PaintDotNet.Imaging.BitmapLockExtensions.AsRegionPtr``1(PaintDotNet.Imaging.IBitmapLock{``0})"/> extension method to
            simplify access to the output buffer.
            </remarks>
        </member>
        <member name="M:PaintDotNet.Effects.IBitmapEffectRenderer.Initialize(PaintDotNet.Effects.BitmapEffectInitializeInfo)">
            <summary>
            This must be called before <see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.SetToken(PaintDotNet.Effects.EffectConfigToken)"/> is called for the first time.
            </summary>
            <returns>
            The effect's rendering information, including its output pixel format. Any supported pixel format
            may be used when calling <see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.Render(System.Void*,System.Int32,System.IntPtr,PaintDotNet.Imaging.PixelFormat@,PaintDotNet.Rendering.RectInt32)"/>, but using the effect's native pixel format will
            have the best performance due to not needing conversion.
            </returns>
        </member>
        <member name="P:PaintDotNet.Effects.IBitmapEffectRenderer.RenderInfo">
            <summary>
            Gets the effect's rendering information. This property may only be accessed after
            <see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.Initialize(PaintDotNet.Effects.BitmapEffectInitializeInfo)"/> has been called.
            </summary>
            <exception cref="T:System.InvalidOperationException"><see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.Initialize(PaintDotNet.Effects.BitmapEffectInitializeInfo)"/> must be called first.</exception>
        </member>
        <member name="M:PaintDotNet.Effects.IBitmapEffectRenderer.SetToken(PaintDotNet.Effects.EffectConfigToken)">
            <summary>
            This should be called when the token changes, such as when the user makes changes in the effect's
            configuration dialog. This must be called once before rendering may begin. This should only be
            called when there are no threads busy with calls to <see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.Render(System.Void*,System.Int32,System.IntPtr,PaintDotNet.Imaging.PixelFormat@,PaintDotNet.Rendering.RectInt32)"/>.
            </summary>
            <param name="newToken">
            The effect configuration token. This may only be null if the effect is not configurable, as
            determined by <see cref="P:PaintDotNet.Effects.IEffectOptions.IsConfigurable"/>.
            </param>
            <exception cref="T:System.InvalidOperationException"><see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.Initialize(PaintDotNet.Effects.BitmapEffectInitializeInfo)"/> must be called first.</exception>
        </member>
        <member name="M:PaintDotNet.Effects.IBitmapEffectRenderer.Render(System.Void*,System.Int32,System.IntPtr,PaintDotNet.Imaging.PixelFormat@,PaintDotNet.Rendering.RectInt32)">
            <summary>
            Renders the requested area and stores the result in the given buffer. The entire buffer is
            written to, including areas that are outside of the selection. The caller must perform any
            masking or blending.
            </summary>
            <remarks>
            Any pixel format can be used for the buffer. If it matches the pixel format that the effect is
            using for its output buffer, no conversion will be necessary and performance will be optimal.<br/>
            <br/>
            This method will handle clearing / zero-filling the buffer if necessary based on whether the
            effect uses <see cref="F:PaintDotNet.Effects.BitmapEffectRenderingFlags.UninitializedOutputBuffer"/>. It is never
            necessary for the caller to clear / zero-fill the buffer before passing it to this method.
            </remarks>
            <exception cref="T:System.InvalidOperationException"><see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.Initialize(PaintDotNet.Effects.BitmapEffectInitializeInfo)"/> must be called first.</exception>
        </member>
        <member name="P:PaintDotNet.Effects.IBitmapEffectRenderInfo.OutputPixelFormat">
            <summary>
            Sets the pixel format for the output buffer.
            </summary>
            <remarks>
            If the effect does not set this property, the output buffer will default to <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/>.<br/>
            <br/>
            The effect must use the same pixel format when retrieving its output buffer with
            <see cref="M:PaintDotNet.Effects.IBitmapEffectOutput.Lock(PaintDotNet.Imaging.PixelFormat@)"/>.<br/>
            <br/>
            Setting this value does not guarantee that the effect's output will be stored in any particular pixel
            format, but it permits the effect infrastructure to know ahead-of-time the format and precision that
            is optimal for the effect.
            </remarks>
            <exception cref="T:PaintDotNet.Imaging.UnsupportedPixelFormatException">The pixel format is not supported.</exception>
        </member>
        <member name="P:PaintDotNet.Effects.IClassicEffectRenderer.RenderInfo">
            <summary>
            Gets the effect's rendering information.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.IClassicEffectRenderer.Render(System.ReadOnlySpan{PaintDotNet.Rendering.RectInt32})">
            <summary>
            Renders into the destination. Only the specified rectangles in the destination are written to.
            </summary>
            <param name="renderRects">The ares to render.</param>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectDocumentInfo.Size">
            <summary>
            Gets the size, in pixels, of the document and all of its layers.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectDocumentInfo.Resolution">
            <summary>
            The resolution of the image, in dots-per-inch (DPI) or dots-per-centimeter (DPCM).
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectDocumentInfo.Metadata">
            <summary>
            Provides access to the image's metadata (EXIF, IPTC, and XMP).
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectDocumentInfo.Layers">
            <summary>
            Gets a list of the document's layers, which can be used to access their properties and get bitmaps
            that render them.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.IEffectDocumentInfo.GetBitmap(PaintDotNet.Imaging.PixelFormat@)">
            <summary>
            Gets a bitmap that renders the document in the requested pixel format. This is the full composition
            of the document, including all of the layers with their rendering properties applied (blend mode,
            opacity, and visibility).
            </summary>
            <param name="pixelFormat">
            The requested pixel format for the bitmap. The native pixel format used by Paint.NET is currently
            <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/>. Specifying a different pixel format is valid, but will incur
            conversion overhead.
            </param>
            <returns>The bitmap.</returns>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectEnvironment.PrimaryColor">
            <summary>
            Gets the primary color selected by the user.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectEnvironment.SecondaryColor">
            <summary>
            Gets the secondary color selected by the user.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectEnvironment.BrushSize">
            <summary>
            Gets the current brush size selected by the user.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectEnvironment.Document">
            <summary>
            Gets an object that provides information about the document, a bitmap that contains
            its full composition, and information and bitmaps about the layers in the document.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectEnvironment.SourceLayerIndex">
            <summary>
            Gets the index of the source layer, which is the layer currently selected by the user.
            This should be the primary input for the effect rendering.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectEnvironment.Selection">
            <summary>
            Gets an object that provides information about the currently selected area.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectInfo.AssemblyLocation">
            <summary>
            The path to the assembly that contains the plugin. Type.Assembly.Location should not be used,
            as it may be different or blank due to compatibility shimming.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectInfo2.AssemblyLocation">
            <summary>
            The path to the assembly that contains the plugin. Type.Assembly.Location should not be used,
            as it may be different or blank due to compatibility shimming.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectLayerInfo.Name">
            <summary>
            Gets the name of the layer.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectLayerInfo.Visible">
            <summary>
            Gets a flag indicating whether the layer is visible or not.
            </summary>
            <remarks>
            This property can be true even if <see cref="P:PaintDotNet.Effects.IEffectLayerInfo.Opacity"/> is false.
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectLayerInfo.Opacity">
            <summary>
            Gets the opacity of the layer. The range is [0, 1].
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectLayerInfo.BlendMode">
            <summary>
            Gets the blend mode of the layer.
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.IEffectLayerInfo.GetBitmap(PaintDotNet.Imaging.PixelFormat@)">
            <summary>
            Gets a bitmap that renders the layer's contents in the requested pixel format.
            </summary>
            <param name="pixelFormat">
            The requested pixel format for the bitmap. The native pixel format used by Paint.NET is currently
            <see cref="P:PaintDotNet.Imaging.PixelFormats.Bgra32"/>, which can be accessed using the <see cref="T:PaintDotNet.Imaging.ColorBgra32"/> struct.
            Specifying a different pixel format is valid, but will incur conversion overhead.
            </param>
            <returns>The bitmap.</returns>
            <remarks>
            This bitmap does not take <see cref="P:PaintDotNet.Effects.IEffectLayerInfo.Visible"/> or <see cref="P:PaintDotNet.Effects.IEffectLayerInfo.Opacity"/> into account.
            </remarks>
        </member>
        <member name="T:PaintDotNet.Effects.IEffectRenderer">
            <summary>
            Used by an effect host to drive the rendering for an effect. These are created by calling <see cref="M:PaintDotNet.Effects.IEffect.CreateRenderer(System.Type)"/>.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectRenderer.Effect">
            <summary>
            Gets a reference to the effect.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectRenderer.IsCancelRequested">
            <summary>
            Gets a flag indicating whether cancellation has been requested.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectRenderer.CancellationToken">
            <summary>
            Gets the cancellation token for the current rendering task. This should not be cached --
            it is recreated whenever rendering is started (e.g. when the token changes).
            </summary>
        </member>
        <member name="M:PaintDotNet.Effects.IEffectRenderer.CancelRendering">
            <summary>
            Signals to the effect that it should cancel rendering. Threads that are currently rendering
            will either return early without completing rendering, or will throw an <see cref="T:System.OperationCanceledException"/>.
            Calling this method does not guarantee that the effect will honor the cancellation
            request for threads that are currently rendering, but it will prevent new rendering calls
            from performing any work until the next token change (e.g. with <see cref="M:PaintDotNet.Effects.IBitmapEffectRenderer.SetToken(PaintDotNet.Effects.EffectConfigToken)"/>).
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectSelectionInfo.RenderBounds">
            <summary>
            Gets the rendering bounds of the selection, in pixels.
            </summary>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectSelectionInfo.RenderScans">
            <summary>
            Gets a list of rectangles that that are affected by the selection. These are the "regions of interest,"
            aka "rois." The rectangles are sorted in left-to-right, top-to-bottom order (&quot;typewrite order&quot;).
            </summary>
            <remarks>
            If EffectFlags.DisableSelectionClipping is used, the rectangles sent to Effect.Render() will not
            match the rectangles available from this property. 
            </remarks>
        </member>
        <member name="P:PaintDotNet.Effects.IEffectSelectionInfo.MaskBitmap">
            <summary>
            Gets a bitmap containing a per-pixel mask. Pixels will have an alpha value representing the
            coverage of the selection at that pixel: 0 for no coverage, 255 for full coverage, and
            in-between values for areas that are partially covered (due to antialiasing/feathering).
            </summary>
            <returns>The mask bitmap.</returns>
        </member>
        <member name="T:PaintDotNet.Effects.PropertyBasedEffect">
            <summary>
            The base class for &quot;classic&quot; effects that use IndirectUI.<br/>
            <br/>
            <b>NOTE:</b> It is strongly recommended that you derive from <see cref="T:PaintDotNet.Effects.PropertyBasedBitmapEffect"/> instead.
            </summary>
        </member>
    </members>
</doc>
