Grafics Class08 Light PDF

Graphics Programming
Light
aevans@salleurl.edu
Programación de Gráficos 3D
1
Alun Evans – aevans@salleurl.edu
RGB colour model
Additive colour model - adding ‘primary’ colours to black

(i.e. white = maximum)
Device dependent
Good because it fits in with

wavelength of eye cones
2
Applying colour to a triangle
1) Interpolate vertex colour
2) Send colour as uniform
3) Send colour as texture
3
Spot the difference
4
Spot the difference
5
The difference is light!
6
Making things more realistic
Simulating shading with LIGHT
7
Materials in 3D graphics
In 3D graphics, we use the term Material to describe the

properties of an object and how it reacts to light.
The properties of a material are used in the equations and

techniques to calculate the pixel painted on the screen.
Material != Surface/Object
8
Light - diffuse
9
Diffuse reflection
Light hits surface, is scattered either due to irregular

surface OR sub-surface and emerges in different
directions
10
Coloured diffuse reflection
A white material absorbs no light - it reflects all

wavelengths
Some materials absorb certain wavelengths and reflect

others - this gives us colour
11
Light - specular
12
Specular reflection
Mirror-like reflection of light
Colour is specular colour of surface
the ‘white spots’ on

objects
13
Mixing specular and diffuse
14
In the real world
15
(nearly) perfect specular reflection
16
Almost zero specular reflection
17
Sub surface scattering
18
Simulating this in graphics
Graphics is always a simulation!
19
Two models of illumination
1. Local 2. Global
Illumination Illumination
Pixels on screen
20
1. Local (Direct) illumination
Each object in the scene is shaded independently (with
special exceptions such as reflective surfaces) relative to light
sources
Usually much faster than global illumination, but also
much less realistic
21
Global Illumination
Models inter-reflection i.e. the colour of one object gets

transferred to another
e.g Ray Tracing, Radiosity (Study it in Grafics II)
22
Global vs Local Illumination
23
Local Illumination
We’re going to work almost exclusively with Local

Illumination
Why? It’s much much faster
(plus, it’s also ‘easier’!)
24
Illuminating a surface with light
25
How did they shade Virtua Fighter?
First polygon based fighting game
(just before Tekken)
1993 in arcades (by Sega)
1995 on Sega Saturn
Each polygon has a colour
The colour of the pixels on the

screen changes proportionally
according to the amount of light
hitting the polygon
26
Lambertian reflection
… says that the radiant intensity

from an ideal diffusely reflecting surface
is directly proportional
to the cosine of the angle θ

between the vector from the surface to the light
and the surface normal.
27
Lambert’s Law
28
How do we get the cosine of the angle between
two vectors?
The dot product (producto escalar)
29
N dot L
Dot product of Normal Vector (N) and Light Vector (vector

from point to light) (L)
Material colour * NdotL = pixel colour
30
Lambert’s law simulates diffuse reflection
31
Flat Shading - simplest way of shading
Treat every pixel on poly

the same i.e. Normal for
each pixel = face normal
calculate Lambert for each

face, apply colour to each
pixel
32
Modern Flat Shading
33
Calculating surface normal
The cross product (producto vectorial)
34
Flat shading algorithm
For each triangle:

calculate normal
calculate NdotL
For each pixel in triangle:
draw
What’s the problem with flat shading?
35
Flat shading vs smooth shading
36
Henri Gouraud
1971
Realised that if you could

interpolate colour
between vertices
Then you can calculate

the colour at the
vertices too
37
Vertex normals vs Face Normals
38
Gouraud Shading
Calculate colour at each vertex
Interpolate colour across each triangle
39
Gouraud vs flat shading
40
Our lighting model so far...
1) Calculate normal at each vertex by interpolating face

normals
2) Use NdotL to calculate (Lambert) colour at each vertex
3) During raster, for each pixel in poly, calculate

proportional distance to each vertex, and linear
interpolate colour
41
Normals in models
Most modelling packages export per-vertex normals, so
we can load them into GPU memory (faster than
calculating them).
42
Implementing Lambert reflection in OpenGL
43
Before we start, naming conventions in
shaders
attributes are the things that come into the vertex shader
- variables start with a_
varyings are things we pass between shader, variables

start with v_
uniforms are constants in both shaders, variables start

with u_
44
VBOs
VBO: Vertex Position (floats - 3)

Vertex Shader
VBO: Vertex Normal (floats - 3)
VAO
VBO: Vertex UV (floats - 2)
Fragment Shader
VBO: Indices (ints)
Programación de Videojuegos
45
Steps to see normals - same as UVs
1) Add new VBO to read normals of sphere
2) Add new attribute to shader e.g.

in vec3 a_normal;
3) Add new varying to pass normal vector from vertex

shader to fragment shader
4) Normalize normal and paint in shader e.g

vec3 N = normalize(v_normal);
fragColor = vec4(N, 1.0);
46
Visualising normals should look something
like this:
47
Adding light
48
Steps to see normals - same as UVs
1) Add new global light variable to represent direction to light
e.g.
vec3 g_light_dir(100, 100, 100);
2) Create a new uniform in fragment shader to receive the light
3) Upload light direction to shader

glUniform3f(u_light_dir, g_light_dir.x, g_light_dir.y, g_light_dir.z);
49
Calculating NdotL in shader
We must make sure NdotL is greater than 0 to avoid
errors. e.g. this situation makes no sense, as cos(100o)
< 0, so we would be ‘subtracting’ light.
N
50
Calculating NdotL
vec3 L = normalize(u_light_dir);
float NdotL = max( dot(N,L) , 0.0 );
//....
vec3 final_color = texture_color.xyz * NdotL;
fragColor = vec4(final_color, 1.0);
51
Advanced Adding the universe
52
Advanced: add the universe
1. Download milkyway.bmp from estudy
2. Load milkyway.bmp as second texture
3. Draw same sphere geometry a second time, using

different texture. Scale to make it bigger than 1st
sphere
4. call glCullFace(GL_FRONT); before drawing the

universe sphere, so inside of sphere is drawn
53
More advanced
5. Create a second shader which only draws the texture

colour i.e.
fragColor = vec4(texture_color.xyz, 1.0);
6. disable depth test before drawing universe sphere,

enable it afterwards. If you draw the universe before the
earth, the universe will always be behind
7. translate the universe sphere to the camera position

every frame, so camera is always in center of the universe
54

Grafics Class08 Light PDF

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Grafics Class08 Light PDF

Transféré par

Droits d'auteur :

Formats disponibles

Graphics Programming

Additive colour model - adding ‘primary’ colours to black

Good because it fits in with

Simulating shading with LIGHT

In 3D graphics, we use the term Material to describe the

The properties of a material are used in the equations and

Light hits surface, is scattered either due to irregular

A white material absorbs no light - it reflects all

Some materials absorb certain wavelengths and reflect

Mirror-like reflection of light

Colour is specular colour of surface

the ‘white spots’ on

Graphics is always a simulation!

Models inter-reflection i.e. the colour of one object gets

We’re going to work almost exclusively with Local

Why? It’s much much faster

(plus, it’s also ‘easier’!)

1993 in arcades (by Sega)

1995 on Sega Saturn

Each polygon has a colour

The colour of the pixels on the

… says that the radiant intensity

to the cosine of the angle θ

Dot product of Normal Vector (N) and Light Vector (vector

Material colour * NdotL = pixel colour

Treat every pixel on poly

calculate Lambert for each

The cross product (producto vectorial)

For each triangle:

What’s the problem with flat shading?

Realised that if you could

Then you can calculate

Calculate colour at each vertex

Interpolate colour across each triangle

1) Calculate normal at each vertex by interpolating face

2) Use NdotL to calculate (Lambert) colour at each vertex

3) During raster, for each pixel in poly, calculate

varyings are things we pass between shader, variables

uniforms are constants in both shaders, variables start

VBO: Vertex Position (floats - 3)

VBO: Vertex Normal (floats - 3)

2) Add new attribute to shader e.g.

3) Add new varying to pass normal vector from vertex

4) Normalize normal and paint in shader e.g

2) Create a new uniform in fragment shader to receive the light

3) Upload light direction to shader

float NdotL = max( dot(N,L) , 0.0 );

vec3 final_color = texture_color.xyz * NdotL;

fragColor = vec4(final_color, 1.0);

2. Load milkyway.bmp as second texture

3. Draw same sphere geometry a second time, using

4. call glCullFace(GL_FRONT); before drawing the

5. Create a second shader which only draws the texture

6. disable depth test before drawing universe sphere,

7. translate the universe sphere to the camera position

Vous aimerez peut-être aussi