- Joined
- May 18, 1997
- Messages
- 55,695
Samsung Odyssey OLED G95SC 49" DQHD (5120 x 1440) 240Hz UltraWide Curved Screen Gaming Monitor $1100.00
https://www.microcenter.com/product...-240hz-ultrawide-curved-screen-gaming-monitor
Follow along with the video below to see how to install our site as a web app on your home screen.
Note: This feature may not be available in some browsers.
Wow, I almost paid 1300 for it last Christmas and it was back ordered. Then I found the LG Ultra 45 WOLED and never looked back.Samsung Odyssey OLED G95SC 49" DQHD (5120 x 1440) 240Hz UltraWide Curved Screen Gaming Monitor $1100.00
https://www.microcenter.com/product...-240hz-ultrawide-curved-screen-gaming-monitor
View attachment 646571
I have the original G9, and I'm thinking about dipping into the OLED version. Anyone do the same?
I have multiple of both (I purchase ultrawides for all of my engineers at work) and I actually pretty strongly prefer the normal G9 Neo in several ways. For me, the best monitor of all is the 57in Samsung, but the old G9 Neo is very good for productivity. I will caveat this will the fact that I don't really care about gaming performance lately since I simply don't have time to game.
The original G9 has significantly better text to my eyes, it does much better in brightly lit environments, the more aggressive curve is more to my preference, and you don't have to deal with a bunch of Smart TV bullshit that the OLED has. On the flipside, the glossy screen on the OLED makes colors look deeper and the motion smoothness is in theory better. It would be a great gaming screen, no doubt - but personally I don't game much these days.
It really depends on your use case.
I love my 57! It's a work productivity titan and I enjoy gaming on it too!
I'm sure we will see one in next year or two.....but it's gotta deliver HDR1300I want the 57” in oled… right now they only offer it in mini led
Deal is still alive on Amazon, if you check the coupon box you get $100 off and this becomes $999.
Starter Generic Subpixel-Aware Supersampling Algorithm
A small mask bitmap is created for the subpixel structure (what the subpixel structure looks like for one real software-based pixel), which the user can specify. Or the bitmap could be represented as rows of base-4 numbers (0=transparent, 1=red, 2=green, 3=blue) so that it makes visual sense. Or it could be a transparent PNG with alpha channels (adjustable transparent edges), with transparent, red, green, blue. Etc.
Optional: For rare odd screens, such as ASUS Vivabook, you have weird structures for 2x2 groups of pixels. Therefore, you might need to use one bitmap for a 2x2 group of onscreen pixels, for slight further improvements to subpixel rendering. So mask can be configurable dimensions 1x1, 2x1, 1x2, and 2x2 for oddball displays -- one can photograph an OLED screen macro lens, then crop, then downconvert to just red/green/blue, and save the bitmap as a mask bitmap for subpixel rendering.
For every time one font glyph is rendered onscreen:
- Check if the glyph is already in the subpixel-scaled glyph cache (for a specific glyph at a size with all combining marks etc)
If yes, skip to step 5.- Render a single character (font glyph) in-memory at high scaling factor (e.g. 16x size).
Example: If it's a 16point character of Arial, draw it at 256point size within GPU memory- Downscale the supersized font letter through the subpixel-structure bitmask
Example: Use a GPU shader to push the large font letter through the subpixel-structure bitmask during downsample- Cache the resulting downsampled bitmap (for faster run at step 1)
- Draw the glyph onto the screen
The bitmaps should be transparent with an alpha channel, to be compatible with overwritten text / overlay on complex background / linked letters like Arabic / etc).
Basically, pushing a supersized version of the glyph through the subpixel mask during downsample. This is very simple ultra-fast GPU shader code.
Or you could use layering of existing DirectWrite/Direct2D APIs instead (e.g. bitmap scaling and bitmap-combining mathematics similar to ADD, SUBTRACT, AND, OR, XOR, alpha-blend operations etc) instead of GPU shader code. (And many of these APIs compile as shaders anyway when GPU acceleration is enabled). Various settings can be done to adjust.
There should be a "Contrast" setting adjustment like ClearType APIs, which is metaphorically an alphablend between subpixel rendered and not subpixel-rendered.
ClearType Contrast can be simply an alphablend/math between a non-subpixel-compensated glyph and a subpixel-compensated glyph. And configurable supersample size (6x, 8x, 10x, 12x, 14x, 16x, [...]) for quality experiments.
One consideration; there will be loss of OpenType/TrueType "hinting" for small-size fonts (due the large-glyph rendering step) but the resulting correct subpixel render (up to ~3x more resolution possible) without hinting, will look superior to hinted-but-incorrect/blurrier. In other words, the nonstandard-subpixel-structure sharpness improvement outweighs the loss of "hinting" support for the vast majority of fonts -- even for complex fonts such as Mandarin, etc, that goes very soft/blurry on WOLEDs.
Either way, while it sounds difficult at first -- the generic algorithm is actually absurdly simple to a shader programmer or bitmap-mathematics programmer, once they're trained to understand ClearType better (e.g. treat the subpixels like additional pixels spatially)