8.1-rendering.ppt

Rendering

•

Will cover one aspect:

Real Time 3D Rendering

3D scene

renderin

_g

Image

screen

buffer

( 2D array of

N times per

sec

( e.g. N=60

)

Real Time 3D Rendering

Challenging problem! As an example:

•

pixel

= 32 bit = 4 bytes

("pixel depth")

•

screen buffer

= 1024 x 768 pixels

("screen

resolution")

•

frame rate

= 60 Hrz

("fps")

188 MegaBytes / sec

•

_total

_{= 4 x 1024 x 768 x 60 byte al sec}

Real Time 3D Rendering

•

High fill-rates

– note:

...the fill-rate is not always the bottleneck

– note 2:

...this is only a lower bound for the fill-rate.

• We did not consider the

depth-complexity

~

x2.5

(as we

will see...)

• There are more than 32 bit x pixel

Real Time 3D Rendering

•

Difficult task

– Luckily, this is highly parallelizable

•

Basic idea:

Real Time 3D Rendering

•

We will focus on:

Real-Time

Hardware-Based

Spoecialized Hardware for rendering

•

_Pro:

_efficency

• Most frequent commands

hard-wired

in the

chipset

• parallelism rendering/main application

– rendering in the graphic card

– CPU and main RAM used by the application

But most importantly:

• Explotation of the

parallelism

implicit in the rendering

– Parallelismo in the pipeline

– parallelism

in each phase

of the pipeline

•

_Cons:

_{low flexibility}

Rendering paradigms

•

Raytracing

•

Rasterization based

•

Image based (per es. light field)

•

Radiosity

•

Point-splatting

Rasterization-based HW-supported

rendering

•

Also known as:

Transform and Lighting (

T&L

) paradigm

3D scene

renderin

_g

screen

buffer

Few types of primitives:

•

points

•

lines

•

triangles

Rasterization-based HW-supported

rendering

•

_{Assumption: the scene is only composed of}

triangles (or points and lines)

x

z

v

0

=(

x

0

, y

0

, z

0

)

v

1

=(

x

1

, y

1

, z

1

)

Rasterization-based HW-supported

rendering

Assumption:

•

the scene is only composed of triangles (or

points and lines)

Scene only composed of triangles

one quadrilateral?

"quad"

"diagonal

split"

Scene only composed of triangles

an n-sides polygon?

Polygon triangolation:

(not

always trivial...)

Scene only composed of triangles

triangles!

Transform & Lighting

screen

buffer

3D Points

3D

Segments

3D

Triangles

Graphic card

Transform

&

Transform & Lighting...

•

Transform

:

– Trasformations of coordinate systems

– objective: put the scene in front of our (virtual) camera

– Draw the visible triangles on the screen

•

Lighting

:

– Light effects

(in general )

– objective: compute the resulting color for each

fragment of the scene

• Due to:

... Rasterization-Based Rendering

•

More precisely...

3D

vertices

fragment

process

pixels

final

fragments

transform

x

z

v

v

v

rasterizer

y

2D

screen

triangle

v

v

v

Rasterization-Based HW-Supported

Rendering: triangles

x

y

z

v

v

v

Final

pixels

fr

a

g

m

e

n

ts

(c

a

n

d

id

a

te

p

ix

e

ls

)

V

e

rt

ic

e

s

(p

o

in

ts

i

n

R

)

P

ro

je

ct

e

d

v

e

rt

ic

e

s

(p

o

in

ts

i

n

R

)

V

e

rt

e

x

c

o

m

p

u

ta

ti

o

n

s

rasterize

r

Fr

a

g

m

e

n

t

co

m

p

u

ta

ti

o

n

s

set

-up

v

v

Final

pixels

fr

a

g

m

e

n

ts

(c

a

n

d

id

a

te

p

ix

e

ls

)

V

e

rt

ic

e

s

(p

o

in

ts

i

n

R

)

P

ro

je

ct

e

d

v

e

rt

ic

e

s

(p

o

in

ts

i

n

R

)

V

e

rt

e

x

c

o

m

p

u

ta

ti

o

n

s

rasterize

r

Fr

a

g

m

e

n

t

co

m

p

u

ta

ti

o

n

s

set

-up

Rasterization-Based HW-Supported

Rendering

Physical components of the

HW!

Pipeline



Parallelism



Efficiency

Short history: PC...

1996

general purpose

HW (with a CPU)

dedicated HW

(with a GPU)

Short history: PC...

1997

general purpose

HW (con CPU)

dedicated HW

(with a GPU)

Short history: PC...

1999

general purpose

HW (with a CPU)

dedicated HW

(with a GPU)

Rasterization-Based HW-Supported

Rendering: triangles

co

m

p

u

ta

zi

o

n

i

p

e

r

fr

a

m

m

e

n

to

x

y

z

v

v

v

v

v

v

Rasterization-Based HW-Supported

Rendering:

rasterize

r

triangoli

x

y

z

v

v

v

set

-up

v

v

Rasterizing!

Segments Rasterization

• Goal: producing

lines as close as

possible to the

original one

v

₀

v

₁

Working with integer coordinates.

Rounding first.

Segments Rasterization

•

We wanto to identify

the sequence of

fragments that

– Best approximates the

segment

•

hence

Segments Rasterization

Slope

m

1

→

1 fragment per column

dx=9

d

y=

7

Slope

m

>1

→

1 fragment per row

dx=3

d

y=

1

0

Let us consider the previous case,

this is similar

Segments Rasterization:

analytical algorithm

The line equation is:

)

1

m

(

B

m







x

y

dx=9

d

y=

7

Segments Rasterization:

analytical algorithm

The rasterization

starts from (

x

₀

,y

₀

) and

goes to (

x

₁

,y

₁

)

P

₀

Analytical algorithm

For

x

=

x

₀

to

x

₁

•

x

++

•

y

← m

x

+ B

•

round

y to the nearest

integer

Analytical algorithm

•

Select the fragment (pixel) closest to the ideal

(real) line

•

In order to find it you need:

– 1 addition

(a +1 on integers)

– 1 multiplication

(float)

First optimization: algorithm DDA

•

DDA

= Digital Differential Analyzer

•

Do without the multiplication

•

Compute incrementally

First optimization: algorithm DDA

•

Trivially:

x

y

y

_i

_

₁



_i



m



B

)

(

m

1











x

x

y

_i

_i

B

m

₁

1









i

i

x

y

m

1







i

i

y

First optimization: algorithm DDA

For

x

=

x

₀

to

x

₁

x

++

y

← m

x

+ B

round

y to the nearest

integer

output the fragment (x , y)

y ←

y

₀

For

x

=

x

₀

to

x

₁

• x

++

•

y

+=m

• round

y

• output the fragment (x ,

y)

analytical

DDA

Bresenham’s Algorithm

•

Idea:

use only integers

•

Given the last chosen

point, which ones can

we selct now?

•

(assuming 0 < m < 1)

last fragment output

0≤m<1

Eight

possibilities!

Bresenham’s Algorithm

B

m





x

y

B

m







x

y

B

m





x

y

B

m







y

x





B

m





y

x







B

m







x

Bresenham’s Algorithm

•

Only two choices!

– East

– North-East

Choices for

the next one

Last

fragment

P=(x

,y

)

NE

Bresenham’s Algorithm

•

Q is the intersection of

the line with the next

column

Scelte per il

pixel corrente

Ultimo pixel

selezionato

Q

P=(x

,y

)

NE

Bresenham’s Algorithm

•

Q intersection of the

line with next column

•

M is the middlepoint

of the line E-NE

•

We need to figure

out on which side of

the line lies M

Scelte per il

pixel corrente

Ultimo pixel

selezionato

Q

M

P=(x

,y

)

NE

Bresenham’s Algorithm

•

We use the implicit form of the line equation:

0

c

b

a

)

,

F(

x

y



x



y





dx

dx;

dy;











b

c

B

Bresenham’s Algorithm

•

The function F:

– is 0 for all points on

the line

– is positive below the

line

– is negative above the

line

Q

M

NE

Bresenham’s Algorithm

•

In order to choose

among NE and E, we

should check the sign

of

Q

M

NE

E

)

,

1

F(

F(M)







1

₂

p

p

y

Bresenham’s Algorithm

•

Decision variable

d

•

d = F(M),

•

_Hence

c

)

(

b

)

1

(

a

d









1

₂



p

p

y

x

Q

M

NE

Bresenham’s Algorithm

If (d



0)

Then M is above the

line

Choose E

Q

M

NE

Bresenham’s Algorithm

If (d > 0)

Then M is below the

line

Choose NE

Q

M

NE

Bresenham’s Algorithm

If (d = 0)

Then M is on the line

Choose either one (E

or NE)

Q

_M

NE

Bresenham’s Algorithm

•

Final improvement!

•

We can compute d

incrementally!

– (like the y in the DDA)

Choices for the

following one

Choices for

next one

Chosen pixel

M

M

M

P=(x

,y

)

NE

E

?

Bresenham’s Algorithm

•

When I choose E

Choices for the

following one

Choices for

the next one

Chosen pixel

M

M

Q

M

P=(x

,y

)

NE

E

)

(

d

)

(

d

new

old

E

M

F

M

F





• result:

a





_old

new

d

Bresenham’s Algorithm

•

When I choose NE

Choices for the

following one

Choices for

the next one

Chosen pixel

M

M

Q

M

P=(x

,y

)

NE

E

)

(

d

)

(

d

new

old

NE

M

F

M

F





• result:

b

a







_old

new

d

Bresenham’s Algorithm

•

Ok, d is increased by a constant

• (different in the two cases E or NE)

•

What is the starting value ?

2

b

a

)

,

(

F

)

,

1

(

F

d

1

₂

₀

₀

0

0

start



x



y





x

y





2

2

b

a

d

_start







dy



dx

• (

x

₀

,

y

₀

) belongs to the line, hence F(

x

₀

,

y

₀

)

Bresenham’s Algorithm

MidpointLine(

int

x0,

int

y0,

int

x1,

int

y1)

{

int

dx, dy, incrE, incrNE, d, x, y;

while

(x < x1 ) {

if

( d <= 0 ) {

d = d+incrE;

x++;

}

else

{

d = d+incrNE;

x++;

y++;

}

OutputFragment(x, y);

}

}

Integer variables

Choice of E

Initialization

dy = y1-y0;

dx = x1-x0;

d = 2*dy-dx;

incrE = 2*dy;

incrNE = 2*(dy-dx);

x = x0;

y = y0;

Segments of Width > 1

Segments of Width > 1

Segments of Width > 1

•

In OpenGL

void glLineWidth( width );

Not always an integer

(allowed when anti-aliasing