Smaller than pixel?

[GSquadron]

Hi all!
I was reading an article of how gpus work and came upon a stunning and strange sentence:
Pixels are not the smallest unit that can be addressed by the GPU
After reading it all, it didn't explain this.
It would interest me a lot if it is not the smallest unit.
Is it true? And what it is?

 

[Law-II]

Hi

It might refer to this - subpixel
A component of a pixel. Three subpixels make up one pixel, namely one red, one green and one blue subpixel

atb (all the best)

Law-II

 

[Jstn7477]

Yes, pixels are made up of 3 primary colored "subpixels" that are controlled individually. The combination of Red, Green and Blue subpixels with differing brightness of each creates the color of each pixel you see. When all 3 subpixels are of equal brightness, they form the color White.

 

[FordGT90Concept]

The smallest unit sent to a dispay is the pixel (with color information). Inside the GPU, it's all math. The GPU basically takes a snapshot of an area of the math, calls it a pixel, and sends it to output.

 

[Jstn7477]

Yes. The display then takes the "pixel (with color information)" and processes it internally, then sends the appropriate electrical signals to each subpixel and makes each subpixel twist a certain amount (for LCD displays, basically the liquid crystals in the subpixels twist to "open and close" the subpixel, essentially blocking the backlight and the subpixel color filter from being visible on the viewing side) or manipulates the electron beam in a CRT to hit the right phosphor pads that make up the subpixels with the correct level of energy.

 

[TheoneandonlyMrK]

pixels dont exist to the geometry engine in a gpu or most of its core at all ,and untill the rops get involved they dont even matter or get considered

 

[GSquadron]

Ok now after the last comment i got confused!

 

[digibucc]

yeah that's both a bit more info than necessary, and worded a bit confusingly. no offense to the last 2, but the first 3 replies give you a good short explanation.

 

[Kreij]

Here's a bit easier way to visualize it.

Let's say you tell your geometry engine (game engine) to draw a cube.
At this point the engine has no concept of pixels as it only knows that there is a cube (of undetermined final size because it only has vector information) that uses a texture.
The engine then takes other information (like scaling, rotation, lighting, etc), and creates your "rendered" cube, removing non-viewable information (based on camara direction) if told to do so, and also performs AA, AF, etc.
It then looks at the viewport information to see where the cube is in relation to the camera (distance from you) and again sizes it accordingly using the screen capabilities (resoultion, etc.) in pixels.

The order may not be exact in my example, but you can see why pixels have no meaning until the final output is displayed.

Let's say you are playing Skyrim. If you're not you should be.
If you tell the game to make an NPC twice the size (2x scaling), the number of pixels it uses on the screen is completely dependant upon where you are in relation to the NPC. Closer? More pixels, farther less.

Here is info on subpixel rendering
Subpixel rendering is a technique to give the impression of higher resolution due to the way humans see color combinations and the like.
On LCDs (not CRTs) each pixel is made up of 3 color subpixels. There are still only X number of pixels on your screen.

 

[95Viper]

Cleartype uses sub-pixel rendering.

How does ClearType display technology work?

To understand how ClearType works, one first has to understand what makes an LCD screen different from other types of displays. Most screens created images made up of pixels, which when magnified look like single squares. The equivalent of one pixel on an LCD screen is actually composed of three sub-pixels: one red, one green, and one blue (R-G-B). Seen together, these sub-pixel triplets combine to be seen by the human eye as a single pixel.

If we were to look at a single pixel, our eye would see it as in the illustration above. However, if we were to magnify the image, we would see that each pixel is actually made up of three separate subpixels. And so, if when we see white on an LCD screen, we are really looking at red, green and blue stripes.

ClearType

Some info at GRC.com that is interesting: Sub-Pixel Font Rendering Technology

Subpixel rendering From Wikipedia < Kreij beat me to the posting.

Sort of interesting the way the mind and eye work.

 

[Kreij]

Hmmm ... it appears that sub-pixel rendering does have some effect (although not as good) on CRTs (it creates a slight blur).
I assumed (apparently wrongly) that because the three color beams focus on a pixel and blend to create the pixel's final color, that the concept of sub-pixels didn't really apply.
Perhaps the GCs are capable of minute adjustment to beam location within a pixel?
I'm gonna look into this more. Quite interesting (to me at least ).

 

[W1zzard]

direct3d doesnt support cleartype subpixel rendering. i think the OP is talking about something else.

either everything before rasterization, which is just floating point math. or maybe some sort of antialiasing?

 

[Kreij]

This is from a MS blog on the WPF Direct2d API

One of the first things that needed to be done was to change over the rendering code to be based on D3D10.1 rather than D3D9. This decision was made since there were several other technologies being built around this version of the runtime as a basis (10level9, WARP, D3D primitive remoting), and because we see hardware built around this architecture as being the future. This allowed us to design D3D10.1 interoperability, and hence allow these other technologies to interoperate with Direct2D as well.

And later in the blog ...

In the end, what we have built is a hardware accelerated 2D rendering API (with software fallback) with a modern primitive rendering set that allows interoperability with previous APIs as well as the state of the art APIs. We feel that this will be a worthy replacement for GDI and GDI+ for most application development scenarios, and will also be able to complement D3D10.1 in some game development scenarios as well. The componentized fashion that was used to build the full set of technologies will also allow developers to mix and match pieces to build things that were hard to build before, such as being able to render subpixel positioned text directly into Direct3D textures with support for any font.

Looks like DX10.1 and up support subpixel rendering. Another MS page on rendering tiers says subpixel (cleartype) rendering has been around since DX9. (shrug)

 

[W1zzard]

yes but thats only for text. basically what you see on your aero desktop

i dont think any game uses it, also it breaks when the screen is rotated and cleartype doesnt know about that

 

[Kreij]

Yes. Since the subpixels are oriented in a horizonal only pattern, rotating the screen tosses it out the window. Kind of dampens the enthusuasm about SPR, expecially for things like eBook readers.

Looks like SPR is done in the shaders (2.0 and up), so it should be feasable in 3D. I read something about MSAA using a combination of SPR and AA, but I don't remember where I saw that.

You're still writing GPU-Z in MFC (thus GDI/GDI+) aren't you? I think you can do it somehow using GDI+ but it doesn't sound easy, nor is it of any value for your utility. But if you ever get the urge to make GPU-Z a full 3D app .... lol

 

[W1zzard]

gpuz uses subpixel rendering, like almost every other windows application that has standard windows controls

afaik cleartype is not done in shaders. msaa is a completely different technology and does not look suitable to me for ultra high quality font rendering

directwrite AA modes: http://msdn.microsoft.com/en-us/library/dd368118(VS.85).aspx

 

[Kreij]

Windows controls only use it for the fonts, no?

More info ...

A rendering tier value of 2 means that most of the graphics features of WPF should use hardware acceleration provided the necessary system resources have not been exhausted. This corresponds to DirectX version that is greater than or equal to 9.0.

and ...

Text rendering :
Sub-pixel font rendering uses available pixel shaders on the graphics hardware.

Fun stuff.

Edit : I saw the rendering enumeration page, but have no idea what "bi-level text" means.

Edit 2 : My bad, I was going from memory (not a good thing when you get to my age. lol)
It's not MSAA, it's Nvidia's SRAA (which was their response to AMD's MLAA) that uses post-processing techniques for subpixel fiddling.
http://research.nvidia.com/publication/subpixel-reconstruction-antialiasing

 

[95Viper]

Pixels are not the smallest unit that can be addressed by the GPU

Aleksander Dishnica, is this where you found the statement?

Allegro 5.1 reference manual
And, the statement is on this page? Primitives addon

Info: Allegro 4 and Allegro 5 are cross-platform, open source, game programming libraries, primarily for C and C++ developers. Read more details on the introductory page. This is the official web site.