>noooo everything must be linearized because.. because it's incorrect otherwise!!
holy midwit. As i already said, your browser doesnt linearize while scaling, youtube's player don't linearize while scaling, your image viewer doesn't linearize while scaling, VLC/ffplay doesn't linearize while scaling. Your attempts to get "correct" results are futile, and no one in the industry cares. Even studios who print 1080p BDs (which are just downscales from 4K masters) aren't linearized. They're all gamma uncorrected.
>age of AI upscaling and coloring everything
Even you know this is bullshit, because if this was true then simple acts such as window scaling would be unbearably slow. Tensor cores aren't magic and will always be leagues slower and more inefficient than fixed-hardware GPU interpolation
Pixels aren't squares. Also you will get uneven pixel sizes/image warping if you nearest-neighbor scale to a noninteger factor, which is a very common issue for emulation. The main reason why all of these pointless resampling algorithms even exist is because nearest-neighbor looks like shit.
that's nice but the ones i use do
Bullshit. Linearization is too slow for most low-power hardware like shittops and shitphones. There is no application that defaults to gamma-correction for compatibility reasons.
>Linearization is too slow
what? no it isn't. if you benchmark it with ffmpeg or mpv you'll see it doesn't even affect frame times because the bottleneck is memory speed unless you're using a meme scaler
>Pixels aren't squares
Pixels are pixels and are pixels.
Pixels will always be pixels.
You can represent them as dots to manifest them into the real world, or with RGB stripes, or with pantone color squares under D50 illuminants for a tiled mosaic.
When it comes to RESAMPLING pixels, there's no good way to upsample them. Just enlarge the pixels, and be done with it.
If you have a pipeline that treats them as squares (digital displays, typically, despite them being RGB stripes in physical form in the real world) then you just turn one square into 4 squares to zoom in 2x.
>Also you will get uneven pixel sizes/image warping if you nearest-neighbor scale to a noninteger factor
No shit.
If you must do this bad thing, then it doesn't really matter what you use, the end result will be pretty shit regardless.
>The main reason why all of these pointless resampling algorithms even exist is because nearest-neighbor looks like shit.
No, they're simply using it wrong.
NN+Integer values looks perfect, if you think it looks bad, then that's your content that looks bad and you're misplacing blame. Pixelation ain't such a good look, but it sure beats blur or AI slop.
for me it's integer nearest neighbor.
It's annoying when i'm making "pixel" art projects and having to prevent browsers from doing something moronic by default. it's insane.
For me, it's rendering onto a buffer 1/10th the size the assets were designed for and then up-scaline using Bilenear because I'm too lazy to learn how real console limitations work and I need to jump on the PS1/N64 era nostalgia wave before it's too late.
both consoles had dithering, most games output 15bit colour, though you're unlikely to notice dithering with n64 games due to the hardware anti-alias filter which blurs... everything
N64 had a filtering that was like bilinear but worse. Both Mupen and Duckstation have options for bilinear texture filtering and in full 3D games it actually looks pretty good
the n64 has a rather unique "3 point" bilinear filter, rather than the normal 4 point bilinear, the difference is quite obvious when looking at a texture close up, which you always do on the n64 since the textures were so small
the psx uses a point filter, or in modern terms, no filter, which is easy to replicate, but psx has its' own challenges in terms of replicating how its' graphics worked, notably the fact textures are affine transformed, no perspective correction, and also the fact the 3D math is all done in fixed-point, since it has no floating point unit, making vertices very "wobbly"
2 weeks ago
Anonymous
Good thing modern emulators can eliminate the wobbliness of PS1 games.
2 weeks ago
Anonymous
Yeah, so great that it's possible to intentionally make your game look like complete shit.
2 weeks ago
Anonymous
it's crazy what modern psx emulators can do
stable vertices and perspective textures are nothing special on n64 emulators, since the n64 did those on its own, it's not trivial at all to implement them in a psx emulator
N64 had a filtering that was like bilinear but worse. Both Mupen and Duckstation have options for bilinear texture filtering and in full 3D games it actually looks pretty good
both consoles had dithering, most games output 15bit colour, though you're unlikely to notice dithering with n64 games due to the hardware anti-alias filter which blurs... everything
[...]
the n64 has a rather unique "3 point" bilinear filter, rather than the normal 4 point bilinear, the difference is quite obvious when looking at a texture close up, which you always do on the n64 since the textures were so small
the psx uses a point filter, or in modern terms, no filter, which is easy to replicate, but psx has its' own challenges in terms of replicating how its' graphics worked, notably the fact textures are affine transformed, no perspective correction, and also the fact the 3D math is all done in fixed-point, since it has no floating point unit, making vertices very "wobbly"
it's worth noting that simply using normal bilinear isn't necessarily an upgrade, games were sometimes made to work around the look of 3 point filtering, which you lose if you do that, plus just in general it doesn't look the same, using bilinear just "looks like it's emulated", since that's all emulators could do for a long time
Good thing modern emulators can eliminate the wobbliness of PS1 games.
i was so amazed when i first heard about that, at first i wondered why emulators didn't fix that, then i read into why it happens, so for a long time i understood that it wasn't possible, then they go and find a way anyway
Yeah, so great that it's possible to intentionally make your game look like complete shit.
i think you misread his point, he said "eliminate", not "emulate". until recently emulators reproduced the same wobbly vertices and not because of some desire to be faithful, but because it was an actual technical limitation of the console, all the math was done with integers, so while you could scale the graphics up, vertices were still stuck on the original, very coarse integer grid
2 weeks ago
Anonymous
Overlay is beautiful and crisp on the right. Looks like shit on left.
Clever filtering makes the edge of stairs look great.
nooooooo
you heckin have to resamplerino the pixelerinos, they're not actually squares! they can be blurred and stretched to look not pixelated!!!
seriously
just resizing the pixels is very BAD because you can see pixels! okay?
gosh
ur so stubern and stupit
the human eye does not see in pixels
if you look at computer screen or television and don't have to ask "what the frick am I looking at?" you are doing it wrong and need to blur the pixels more until that happens
2 weeks ago
Anonymous
Did you fail your computer graphics course or something? What's with this unbridled seething at basic low-pass filtering?
>scan drawing I made in 1200dpi >decide that its too wide, scale it lower horizontally
Is there any point to using something besides nearest? At that resolution I don't think it's noticeable either way and in the end it will then get scaled down to something that actually fits on a computer screen.
I also kind of like the sharp look of scaling down with nearest
you're still going to encounter that issue, and even worse, your image will be full of high contrast and high frequency information, which means bad moire and aliasing.
you're still going to encounter that issue, and even worse, your image will be full of high contrast and high frequency information, which means bad moire and aliasing.
If you're downsampling, use bicubic or something at least.
Unless you're downsampling by integers, like taking a 1200 DPI scan of an 8x10 drawing and turning it into a square, you can scale that by integers down.
8x1200=9600
10x1200=12000
If you scaled this image down to 2400x2400, you can do 25% width and 20% height, integer scaled with NN or Linear with good results.
If you do anything even scaling a 1600x900 image into 1280x720 NN won't do good. Use bicubic or leave it in original size, and leave the future user to resample/display as desired without baking scaling artifacts into the original content.
In general, always avoid scaling. It's always bad.
Even a small adjustment like changing a 4000x4800 image into 4000x4600 will scale ALL the pixels slightly and cause issues.
this looks like they were scaled without being gamma corrected first
Gamma correction is a meme, most applications like image viewers and media players don't even apply gamma correction while scaling.
that's nice but the ones i use do
Absolute midwit take. Everything looks darker than nearest without it.
>noooo everything must be linearized because.. because it's incorrect otherwise!!
holy midwit. As i already said, your browser doesnt linearize while scaling, youtube's player don't linearize while scaling, your image viewer doesn't linearize while scaling, VLC/ffplay doesn't linearize while scaling. Your attempts to get "correct" results are futile, and no one in the industry cares. Even studios who print 1080p BDs (which are just downscales from 4K masters) aren't linearized. They're all gamma uncorrected.
Cope.
The pixels could do with being converted from RGB to HSL before being interpolated. The results here look muddy.
>caring about this in the age of AI upscaling and coloring everything easily
>age of AI upscaling and coloring everything
Even you know this is bullshit, because if this was true then simple acts such as window scaling would be unbearably slow. Tensor cores aren't magic and will always be leagues slower and more inefficient than fixed-hardware GPU interpolation
AI upscaling is heavy and looks like shit at anything lower than 1080p
Nearest is only good in pixel art
If you're using anything but None/Nearest at integer values for upscaling you're doing it wrong.
If you're downsampling, well, that's more forgiving.
Pixels aren't squares. Also you will get uneven pixel sizes/image warping if you nearest-neighbor scale to a noninteger factor, which is a very common issue for emulation. The main reason why all of these pointless resampling algorithms even exist is because nearest-neighbor looks like shit.
Bullshit. Linearization is too slow for most low-power hardware like shittops and shitphones. There is no application that defaults to gamma-correction for compatibility reasons.
>Linearization is too slow
what? no it isn't. if you benchmark it with ffmpeg or mpv you'll see it doesn't even affect frame times because the bottleneck is memory speed unless you're using a meme scaler
ffplay doesn't even default to linearized scaling. And neither does mpv.
>Pixels aren't squares
Pixels are pixels and are pixels.
Pixels will always be pixels.
You can represent them as dots to manifest them into the real world, or with RGB stripes, or with pantone color squares under D50 illuminants for a tiled mosaic.
When it comes to RESAMPLING pixels, there's no good way to upsample them. Just enlarge the pixels, and be done with it.
If you have a pipeline that treats them as squares (digital displays, typically, despite them being RGB stripes in physical form in the real world) then you just turn one square into 4 squares to zoom in 2x.
>Also you will get uneven pixel sizes/image warping if you nearest-neighbor scale to a noninteger factor
No shit.
If you must do this bad thing, then it doesn't really matter what you use, the end result will be pretty shit regardless.
>The main reason why all of these pointless resampling algorithms even exist is because nearest-neighbor looks like shit.
No, they're simply using it wrong.
NN+Integer values looks perfect, if you think it looks bad, then that's your content that looks bad and you're misplacing blame. Pixelation ain't such a good look, but it sure beats blur or AI slop.
>if you're not doing [objectively shittiest option] you're doing it wrong
thats how you get yous!! say the stupidest "wrongest" shit ever and receive the dopamine
This. NN when upscaling, lanczos when downscaling.
For me, none and nearest
for me it's integer nearest neighbor.
It's annoying when i'm making "pixel" art projects and having to prevent browsers from doing something moronic by default. it's insane.
ARR ROOK SAME!!
bilinearbros ww@
all nearest neighbour Black folk must fricking hang
They all look moronic, what fricking use case would someone need for those?
For me, it's rendering onto a buffer 1/10th the size the assets were designed for and then up-scaline using Bilenear because I'm too lazy to learn how real console limitations work and I need to jump on the PS1/N64 era nostalgia wave before it's too late.
neither the ps1 nor n64 used bilinear interpolation
trust me bro, this is retro. just add some inappropriate dithering and some high-contrast neon colors like totally all of the PS1 and N64 games had
both consoles had dithering, most games output 15bit colour, though you're unlikely to notice dithering with n64 games due to the hardware anti-alias filter which blurs... everything
the n64 has a rather unique "3 point" bilinear filter, rather than the normal 4 point bilinear, the difference is quite obvious when looking at a texture close up, which you always do on the n64 since the textures were so small
the psx uses a point filter, or in modern terms, no filter, which is easy to replicate, but psx has its' own challenges in terms of replicating how its' graphics worked, notably the fact textures are affine transformed, no perspective correction, and also the fact the 3D math is all done in fixed-point, since it has no floating point unit, making vertices very "wobbly"
Good thing modern emulators can eliminate the wobbliness of PS1 games.
Yeah, so great that it's possible to intentionally make your game look like complete shit.
it's crazy what modern psx emulators can do
stable vertices and perspective textures are nothing special on n64 emulators, since the n64 did those on its own, it's not trivial at all to implement them in a psx emulator
N64 had a filtering that was like bilinear but worse. Both Mupen and Duckstation have options for bilinear texture filtering and in full 3D games it actually looks pretty good
it's worth noting that simply using normal bilinear isn't necessarily an upgrade, games were sometimes made to work around the look of 3 point filtering, which you lose if you do that, plus just in general it doesn't look the same, using bilinear just "looks like it's emulated", since that's all emulators could do for a long time
i was so amazed when i first heard about that, at first i wondered why emulators didn't fix that, then i read into why it happens, so for a long time i understood that it wasn't possible, then they go and find a way anyway
i think you misread his point, he said "eliminate", not "emulate". until recently emulators reproduced the same wobbly vertices and not because of some desire to be faithful, but because it was an actual technical limitation of the console, all the math was done with integers, so while you could scale the graphics up, vertices were still stuck on the original, very coarse integer grid
Overlay is beautiful and crisp on the right. Looks like shit on left.
Clever filtering makes the edge of stairs look great.
>none
Just use ewa_lanczossharp with AR until the AI scalers catch up in accuracy and power consumption
none/nearest looks best.
Everything else is a blurry mess.
nooooooo
you heckin have to resamplerino the pixelerinos, they're not actually squares! they can be blurred and stretched to look not pixelated!!!
seriously
just resizing the pixels is very BAD because you can see pixels! okay?
>okay?
What are you asking?
ACCEPT THAT WE MUST BLUR THE PIXELS
LUDDITE
gosh
ur so stubern and stupit
the human eye does not see in pixels
if you look at computer screen or television and don't have to ask "what the frick am I looking at?" you are doing it wrong and need to blur the pixels more until that happens
Did you fail your computer graphics course or something? What's with this unbridled seething at basic low-pass filtering?
People yearn for the seams.
nice artificial test case
now show some comparisons of real-world samples
I like Lanczos because the painterly effect is cool
Painterly effect? You mean the antialiasing?
yes
I like spline36 and lanczos, altough they are a bit too slow, in which case I'd rather use catmull-rom, then mitchell, then hermite
scale=ewa_lanczossharp
dscale=catmull_rom
there's a thread on /gif/ where the OP is a webm of a girl shitting out candy and that shit looks like pic related
>scan drawing I made in 1200dpi
>decide that its too wide, scale it lower horizontally
Is there any point to using something besides nearest? At that resolution I don't think it's noticeable either way and in the end it will then get scaled down to something that actually fits on a computer screen.
I also kind of like the sharp look of scaling down with nearest
uneven pixel sizes
But I'm scaling it down from an absurdly high resolution anyway
you're still going to encounter that issue, and even worse, your image will be full of high contrast and high frequency information, which means bad moire and aliasing.
m-n for comparison
If you're downsampling, use bicubic or something at least.
Unless you're downsampling by integers, like taking a 1200 DPI scan of an 8x10 drawing and turning it into a square, you can scale that by integers down.
8x1200=9600
10x1200=12000
If you scaled this image down to 2400x2400, you can do 25% width and 20% height, integer scaled with NN or Linear with good results.
If you do anything even scaling a 1600x900 image into 1280x720 NN won't do good. Use bicubic or leave it in original size, and leave the future user to resample/display as desired without baking scaling artifacts into the original content.
In general, always avoid scaling. It's always bad.
Even a small adjustment like changing a 4000x4800 image into 4000x4600 will scale ALL the pixels slightly and cause issues.