Rick Brewster

This has been possible for ages, it's not news It's not supported (or even supportable) obviously, and doesn't even work quite right as you see. As far as I've seen there's been no movement on WINE's ability to support PDN 4.0+, which was released in mid-2014. For some reason they haven't managed to fully implement Direct2D or UIAnimation in the last ... decade. Direct2D is more understandable, but UIAnimation? *shakes head*

I said it could be as simple as a Windows Update being installed. "Another installation is in progress" couldn't refer to PDN in this case. But, in any event, Windows isn't lying. Another installation ... of something ... is in progress.

I've seen this for Stable Diffusion grid outputs, where you tell it to generate like 9 variations across 10 different models.

It is absolutely 100% without a doubt signed correctly. If it weren't, everyone else would be seeing this failure and my inbox would be overflowing. Also, I would've fixed it at some point in the last 2 months since this version was released. The problem is definitely on your end.

The image is too big .... different formats have different maximum sizes. There is no way around this. There is nothing you can do other than reduce the size of your image. PDN has no maximum size, although File->New won't let you go above 262,144px (you'd need like 512GB of RAM to work with an image like that and it would be suuuuuuuuuuuuuuuuuuuuuuuper duper slow ...)

It will be possible to work with the color profile in the upcoming 5.1 release. A significant portion of the "back end" rendering engine has been upgraded and rewritten to accommodate this and to get ready for future upgrades (e.g. high bit-depth support, and maybe even HDR support). ("c2" seems to be a size-optimized sRGB-ish profile that I've seen many images using ...)

@Timo Kinnunen There's a few things here. First, SampleMapRenderer is a bit picky due to some low-level internal Direct2D particulars. You will need to wrap Environment.SourceImage by using deviceContext.CreateBufferedImage(), and use that image instead of Environment.SourceImage. I've already seen this happen in another situation where it throws an InvalidGraphConfiguration, and I put in a special error message to direct folks to CreateBufferedImage(), but it looks like the effect graph you're creating is resulting in a cyclic graph instead. I'm not entirely sure how/why, but the DynamicImage framework (which SampleMapRenderer is based on) does some really really crazy stuff to achieve what it's doing, and it may be putting Direct2D into a state that just doesn't make sense. Second, SampleMapRenderer is definitely not the right tool to use for what you're doing. SampleMapRenderer is meant for distortion effects, like Effects -> Distort -> Dents, which sample pixels from all over the image. In order to achieve this, it requires a LOT of processing power in the general case (the internal effects have access to a property that helps to massively reduce that). You're only doing a sampling offset of +/- 0.25 pixels, so SMR is horrendously inefficient. Since your sampling is so simple, try using DisplacementMapEffect instead ( PDN docs, MSFT docs ). Outside of CodeLab, this would probably be best done with a custom shader written with ComputeSharp.D2D1.

This is almost certainly the issue. The code signing certificate being used via Azure Trusted Signing* requires a newer set of updates. If this were the case, then extracting the downloaded ZIP would have failed and it would be a different error. * formerly Azure Code Signing

When a new version of the plugin is released, however, you do need to update the plugin itself manually/separately. Paint.NET does not manage updates for plugins.

Glad to hear it!

Those could easily just be left over from old versions from when they were current

btw this future release is 5.1, and I'm hoping to push out a public alpha in the next few weeks, so be sure to try it out!

I would not go exploring the registry and deleting things. That is often a recipe for making things worse.

What version of Paint.NET are you on though?

Should just need a reboot, not a forced uninstall. "Another installation is already in progress" can just mean something as simple as Windows Update doing some stuff in the background.

The MSI is generally only used when doing a network-wide deployment, like in a school or business ("enterprise") or something like that. It's not really a good option for individual installs.

This is also an error that we've seen happen when someone uses one of those "slim down your Windows install! get rid of all the bLoAAAAtttt!" utilities. If you uninstall WIA, you can't use WIA to print.

You can just hold Ctrl when you want to sample the image instead of the layer (it says this in the status bar at the bottom, btw)

Yeah this doesn't really make sense... PDN never hides the image

The diagnostics info that @Tactilis requested will tell us where this file is, and that usually gives more information about what it is. But, this is definitely not a Paint.NET bug -- HookTool64.dll is definitely the culprit.

(The term you're looking for is "canvas") This isn't currently possible but is something I'm considering for the upcoming 5.1 release. Maybe not the color but at least the brightness.

There are also these effects: https://paintdotnet.github.io/apidocs/api/PaintDotNet.Direct2D1.Effects.html The effects you can chain together are Direct2D effects. You can write a Paint.NET effect (yes the term "effect" is overloaded) that chains them together, but you can't combine Paint.NET effects like that. But that shouldn't matter because all of the bulit-in Paint.NET effects are essentially UI wrappers for the Direct2D effects. The effects whose names begin with "Pdn" are the Direct2D effects that power the built-in Paint.NET effects that you see in the app menus.

You can use Environment.GetSourceBitmapBgra32(), which will give you an IEffectInputBitmap<ColorBgra32>. Then call Lock() to get the IBitmapLock<ColorBgra32>(). Then use AsRegionPtr() to get it as a RegionPtr<ColorBgra32> which you can just index into, e.g. region[x, y]. Then just compare region[x, y].A == 255 to determine if it's opaque. Note that this works fine for querying the alpha channel, as the alpha channel is invariant with respect to color space (sRGB vs. linear scRGB vs. whatever other color profile they might have on the image!). If you want to query the RGB values, they won't line up with the color space you're using in the GPU effect, and it'll take some extra work to determine the right thing to do. So that's a topic for another time.

I kicked the tires a little, seems to work great

We do not provide any support unless you're using the latest version of Paint.NET.