| Server IP : 121.121.20.254 / Your IP : 216.73.217.51 Web Server : Microsoft-IIS/10.0 System : Windows NT WEB-SERVER 10.0 build 20348 (Windows Server 2022) AMD64 User : IUSR ( 0) PHP Version : 8.3.28 Disable Function : NONE MySQL : ON | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/Program Files/paint.net/ |
Upload File : |
<?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 "classic" 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.Clone(PaintDotNet.Effects.IEffectEnvironment)">
<summary>
Creates a copy of the environment for use with another effect instance.<br/>
<br/>
Either this method or <see cref="M:PaintDotNet.Effects.EffectEnvironmentExtensions.CloneWithNewSource(PaintDotNet.Effects.IEffectEnvironment,PaintDotNet.Imaging.IBitmapSource)"/>
must be used when an effect creates another effect with <see cref="T:PaintDotNet.Effects.IEffectsService2"/>
and wishes to pass along its environment to the new effect.
</summary>
<param name="environment">The environment to clone from.</param>
<returns>The new environment.</returns>
<remarks>
The new environment object must be bound to a new effect instance with
<see cref="M:PaintDotNet.Effects.IEffect.Initialize(System.IServiceProvider,PaintDotNet.Effects.IEffectEnvironment)"/>.<br/>
<br/>
The new environment object will not implement derived interfaces such as
<see cref="T:PaintDotNet.Effects.IBitmapEffectEnvironment"/> or <see cref="T:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment"/>. Once the
environment has been bound to a new effect instance, any such interfaces will then be
made available to the new effect instance through its local <c>Environment</c> property.<br/>
<br/>
Copying an environment is not expensive. Most of the data is shared, it is only the state
management that needs to be separate for each effect.
</remarks>
</member>
<member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.CloneWithNewUserColors(PaintDotNet.Effects.IEffectEnvironment,PaintDotNet.Imaging.ColorBgra32,PaintDotNet.Imaging.ColorBgra32)">
<summary>
Creates a copy of the environment for use with another effect instance, while replacing the
primary and secondary colors. Other data is unaffected.<br/>
</summary>
<param name="environment">The environment to clone from.</param>
<param name="newPrimaryColor">The new value for the <see cref="P:PaintDotNet.Effects.IEffectEnvironment.PrimaryColor"/> property.</param>
<param name="newSecondaryColor">The new value for the <see cref="P:PaintDotNet.Effects.IEffectEnvironment.SecondaryColor"/> property.</param>
<returns>The new environment.</returns>
<remarks>
<inheritdoc cref="M:PaintDotNet.Effects.EffectEnvironmentExtensions.Clone(PaintDotNet.Effects.IEffectEnvironment)"/>
</remarks>
</member>
<member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.CloneWithNewBrushSize(PaintDotNet.Effects.IEffectEnvironment,System.Single)">
<summary>
Creates a copy of the environment for use with another effect instance, while replacing the
primary and secondary colors. Other data is unaffected.<br/>
</summary>
<param name="environment">The environment to clone from.</param>
<param name="newBrushSize">The new value for the <see cref="P:PaintDotNet.Effects.IEffectEnvironment.BrushSize"/> property.</param>
<returns>The new environment.</returns>
<remarks>
<inheritdoc cref="M:PaintDotNet.Effects.EffectEnvironmentExtensions.Clone(PaintDotNet.Effects.IEffectEnvironment)"/>
</remarks>
</member>
<member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.CloneWithNewSource(PaintDotNet.Effects.IEffectEnvironment,PaintDotNet.Imaging.IBitmapSource)">
<summary>
Creates a copy of the environment for use with another effect instance, while replacing the
source layer's bitmap. Other data is unaffected, including the document's bitmap.
</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>
<remarks>
<inheritdoc cref="M:PaintDotNet.Effects.EffectEnvironmentExtensions.Clone(PaintDotNet.Effects.IEffectEnvironment)"/>
</remarks>
</member>
<member name="M:PaintDotNet.Effects.EffectEnvironmentExtensions.CloneWithAliasedSelection(PaintDotNet.Effects.IEffectEnvironment)">
<summary>
Creates a copy of the environment for use with another effect instance, while switching the selection
data to aliased mode. This permits an effect that is hosting another effect to specify antialiased
selection quality, but to have the inner effect use aliased selection quality.
</summary>
<param name="environment">The environment.</param>
<returns>The new environment.</returns>
<remarks>
<inheritdoc cref="M:PaintDotNet.Effects.EffectEnvironmentExtensions.Clone(PaintDotNet.Effects.IEffectEnvironment)"/>
</remarks>
</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<TPixel>()</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 "classic" 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/>
<br/>
The color context of the source image is accessible via the <see cref="P:PaintDotNet.Direct2D1.IDeviceImageFormatInfo.ColorContext"/>
property.<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.ImagingFactory">
<summary>
Gets a reference to the <see cref="T:PaintDotNet.Imaging.IImagingFactory"/>.
</summary>
<remarks>
This can also be retrieved by calling <c>this.Services.GetService<IImagingFactory>()</c>.
</remarks>
</member>
<member name="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.Direct2DFactory">
<summary>
Gets a reference to the <see cref="T:PaintDotNet.Direct2D1.IDirect2DFactory"/>.
</summary>
<remarks>
This can also be retrieved by calling <c>this.Services.GetService<IDirect2DFactory>()</c>.
</remarks>
</member>
<member name="P:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment.DirectWriteFactory">
<summary>
Gets a reference to the <see cref="T:PaintDotNet.DirectWrite.IDirectWriteFactory"/>.
</summary>
<remarks>
This can also be retrieved by calling <c>this.Services.GetService<IDirectWriteFactory>()</c>.
</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="T:PaintDotNet.Effects.Gpu.IGpuEffectImage">
<summary>
This is the base interface for GPU images that are accessible from a GPU effect's environment (<see cref="T:PaintDotNet.Effects.Gpu.IGpuEffectEnvironment2"/>).
</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.IBitmapEffectEnvironment.ImagingFactory">
<summary>
Gets a reference to the <see cref="T:PaintDotNet.Imaging.IImagingFactory"/>.
</summary>
<remarks>
This can also be retrieved by calling <c>this.Services.GetService<IImagingFactory>()</c>.
</remarks>
</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="T:PaintDotNet.Effects.IEffectEnvironment">
<summary>
Contains environment information for an effect.
</summary>
</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 ("typewriter order").
</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 "classic" 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>