INTRO mouse mouse mouse mouse

Hello, and welcome for Internet Graphics.

Today, we will look into GPU rendering.

So last week,

I told you about rasterization.

We were learning how we can rasterize lines and polygons.

And yeah, you saw that there are quite efficient algorithms

available to do that.

But nevertheless, if we count all this together,

we will see that the rendering or the rasterization problem

is very, very compute intensive.

So as an example, if you think about programming a computer

game, for instance, what you're aiming for

is a frame rate of 60 frames per second.

That means you have to render a view of your world

60 times per second.

And if you have a normal full HD screen,

that means you have 2 million pixels.

This means you have to set 120 million pixels per second,

which is really a lot, even if you have a good CPU or maybe

also a very fast mobile phone.

120 million pixels per second is a lot.

And we will see later on that per pixel,

we will have to do quite a few computations, maybe even

lighting computations where we simulate light in a scene

and reflection on surfaces and so forth.

We have to do that for each of these pixels.

So it's not only enumerating these pixels

and rasterizing these pixels, but also doing computations

for them and so forth.

So graphics and rendering is very, very compute intensive.

And as a result, very early companies and people

were thinking about how to accelerate this

using dedicated hardware and not to do it

on the standard CPU, but to develop special hardware that

is only made to do these computations efficiently.

And so the typical way to do that is to use parallelization,

because our problem can be rather well parallelized.

If we have a scene with maybe 10 to 100 millions of triangles,

which is common, it's not unusual,

then if you think about the rasterization, for instance,

all these triangles can be rasterized independently.

We can use different processors.

Each one rasterizes a single triangle.

And this can work.

It will need some synchronization in the end

if we write to the frame buffer, but it can work.

And if we look at computing colors of single pixels,

for instance, also, this can be done in parallel.

So there are many jobs that can be done in parallel.