Computer Graphics 10 Lee ByungGook 10282020 Computer Graphics

Computer Graphics 10 Lee Byung-Gook 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 1

Lighting model • • Definition: a set of mathematical equations that calculate the color of each pixel that represents an object. Tradeoffs must be made between the speed of the rendering and the quality of the rendering. In general, as the accurately of the model approaches real world lighting effects, the better the graphics but the slower the rendering High Complex models Quality of graphics Simple models Low Slow Fast Speed of rendering 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 2

Light and object interaction • • When light strikes an object it is: – absorbed and converted to heat, – reflected off the surface, or – refracted (bent) and passed through (e. g. , water, glass, cellophane) For an accurate lighting model, all three interactions must be accounted for, but we will concentrate on reflected light. Reflected light is the light that has bounced off of an object into our eye (or camera). Reflected light is the light we actually see. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 3

Types of reflected light • Ambient light – general light in a room; background light – light that has been scattered in so many directions that it's source cannot be determined – ambient light determines the color of the portion of an object not in direct light. This is sometimes referred to as an object's "back side, " such as the "back side of the moon. " – the relative position of the object, camera, and light sources has no effect on ambient light 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 4

Types of reflected light • Diffuse light – light that comes from one specific direction; scatters in all directions – a surface is brighter (scatters more light) if it is perpendicular to the light direction – diffuse light is what gives an object its predominate color and what makes an object look "curved" or "rounded. " – the relative position of the object to the light sources determines diffuse lighting. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 5

Types of reflected light • Specular light – light that comes from one specific direction and bounces off in one specific direction – the amount of specular light is determined by the smoothness of an object – specular light causes a "hot spot" on shiny objects. The "hot spot" moves as the observer moves – the relative position of the object, camera, and light sources determine the amount of specular lighting. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 6

Lighting Calculations 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 7

Notation • • i = the light number, as in {LIGHT 0, LIGHT 1, LIGHT 2, … LIGHT 7} d = distance between the light's position and the vertex kc = GL_CONSTANT_ATTENUATION kl = GL_LINEAR_ATTENUATION kq = GL_QUADRATIC_ATTENUATION Note: if the light is a "spotlight", the attenuation factors are ignored spotlight_effect – 1, if it is not a spotlight – 0, if it is a spotlight and the vertex is outside the cone of illumination – max {v d, 0}GL_SPOT_EXPONENT where v is the unit vector that points from the spotlight position to the vertex and d is the spotlight direction • • • L = unit vector from the vertex to the light position n = normalized normal vector at the vertex s = (unit vector between the vertex and the light position) + (unit vector between the vertex and the camera position) 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 8

Lab 20 • downloading 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 9

Shade Model • • • void gl. Shade. Model( GLenum mode ); mode : A symbolic value representing a shading technique. Accepted values are GL_FLAT and GL_SMOOTH. The default is GL_SMOOTH. Open. GL only does lighting calculations at the vertices of a face (not every pixel of the face). If the shade model is set to GL_FLAT, then the color calculated for the last vertex specified for the face will be use to color the entire face If the shade model is set to GL_SMOOTH, then the color is calculated for every vertex of the face and the color of interior pixels of the face are interpolated from the colors at the vertices 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 10

gl. Light. Model[f, i] • • These functions set the lighting model parameters. void gl. Light. Modelf(GLenum pname, GLfloat param); void gl. Light. Modeli(GLenum pname, GLint param); pname : A lighting model parameter. The following values are accepted: GL_LIGHT_MODEL_LOCAL_VIEWER GL_LIGHT_MODEL_TWO_SIDE 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 11

gl. Light. Model[f, i]v • • These functions set the lighting model parameters. void gl. Light. Modelfv(GLenum pname, const GLfloat*params); void gl. Light. Modeliv( GLenum pname, const GLint *params); pname : A lighting model parameter. The following values are accepted: GL_LIGHT_MODEL_AMBIENT GL_LIGHT_MODEL_LOCAL_VIEWER GL_LIGHT_MODEL_TWO_SIDE 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 12

Light model parameters • • GL_LIGHT_MODEL_AMBIENT The params parameter contains four integer or floating-point values that specify the ambient RGBA intensity of the entire scene. Integer values are mapped linearly such that the most positive representable value maps to 1. 0, and the most negative representable value maps to – 1. 0. Floating-point values are mapped directly. Neither integer nor floatingpoint values are clamped. The default ambient scene intensity is (0. 2, 1. 0). The ambient of the light model is multiplied by the ambient properties of the material. Think of it as the desired percentage of the material ambient properties The ambient of the material is included for each light source along with the global light model ambient component. Think of the global ambient terms as being the one thing consistent for all objects, totally independent of any light source 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 13

Light model parameters • • GL_LIGHT_MODEL_LOCAL_VIEWER The params parameter is a single integer or floating-point value that specifies how specular reflection angles are computed. If params is 0 (or 0. 0), specular reflection angles take the view direction to be parallel to and in the direction of the –z axis, regardless of the location of the vertex in eye coordinates. Otherwise specular reflections are computed from the origin of the eye coordinate system. The default is 0. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 14

Light model parameters • • if GL_FALSE, the light vector used in the calculations is always the same. This provides faster rendering but poorer quality rendering if GL_TRUE, a new light vector is calculated for each color vertex calculation. This provides better quality rendering but at a slower speed Light Vectors Light Source Object Light Vectors Object 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 15

Light model parameters • • GL_LIGHT_MODEL_TWO_SIDE The params parameter is a single integer or floating-point value that specifies whether one- or two-sided lighting calculations are done for polygons. It has no effect on the lighting calculations for points, lines, or bitmaps. If params is 0 (or 0. 0), one-sided lighting is specified, and only the front material parameters are used in the lighting equation. Otherwise, two-sided lighting is specified. In this case, vertices of backfacing polygons are lighted using the back material parameters, and have their normals reversed before the lighting equation is evaluated. Vertices of front-facing polygons are always lighted using the front material parameters, with no change to their normals. The default is 0. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 16

Light model parameters • • if GL_FALSE, the back side of faces will receive no diffuse or specular light. (only ambient light) if GL_TRUE, the back side of faces is rendered just like the front side of faces. (When the back side is rendered, its normal vector is taken as the reverse of the normal vector for the front side. ) 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 17

Lab 21 • downloading 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 18

gl. Material[f, i] • • • These functions specify material parameters for the lighting model. void gl. Materialf( GLenum face, GLenum pname, GLfloat param ); void gl. Materiali( GLenum face, GLenum pname, GLint param ); face : The face or faces that are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. pname : The single-valued material parameter of the face or faces being updated. Must be GL_SHININESS. param : The value that parameter GL_SHININESS will be set to. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 19

gl. Material[f, I]v • • • These functions specify material parameters for the lighting model. void gl. Materialfv(GLenum face, GLenum pname, const GLfloat *params); void gl. Materialiv(GLenum face, GLenum pname, const GLint *params ); face : The face or faces that are being updated. Must be one of GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK. Pname : The material parameter of the face or faces being updated. The parameters that can be specified using gl. Material, and their interpretations by the lighting equation, are as follows: GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS, GL_AMBIENT_AND_DIFFUSE, GL_COLOR_INDEXES 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 20

Material properties • Percentages – Treat each value used to specify the material properties as a percentage – 0. 0 means 0% color – 1. 0 means 100% color 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 21

Material properties • Material / Light interaction – The ambient, diffuse, and specular components of the material are multiplied by the corresponding properties of light – The ambient color is typically a shade of gray, since the human eye cannot see colors in low light. (Shades of gray have equal values of red, green and blue. ) e. g. , (0. 3, 0. 3) – The diffuse values determine the color (hue) of an object. For example, if you want a red ball, set the diffuse values to (1. 0, 0. 0). 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 22

Material properties – The specular values determine the color (hue) of the hotspot (highlight). Typically the light sources are white, so these values would typically be a shade of white (i. e. , all values equal), such as (0. 8, 0. 8). – The emission values are added directly to the color calculations without any consideration of the light sources or the object's orientation. If the emission values are large (e. g. , > 0. 5), the color of every pixel will typically become saturated (1. 0) and the object will lose all shading. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 23

gl. Light[f, i] • • void gl. Lightf( GLenum light, GLenum pname, GLfloat param ); void gl. Lighti( GLenum light, GLenum pname, GLint param ); light : A light. The number of lights depends on the implementation, but at least eight lights are supported. They are identified by symbolic names of the form GL_LIGHTi where 0 ≤ i < GL_MAX_LIGHTS. pname : A single-valued light source parameter for light. The following values are accepted. GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, GL_QUADRATIC_ATTENUATION param : The value to which parameter pname of light source light will be set. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 24

gl. Light[f, i]v • • void gl. Lightfv( GLenum light, GLenum pname, const GLfloat *params ); void gl. Lightiv( GLenum light, GLenum pname, const GLint *params ); pname : A light source parameter for light. The following values are accepted: GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION , GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION GL_LINEAR_ATTENUATION, GL_QUADRATIC_ATTENUATION params : A pointer to the value or values to which parameter pname of light source light will be set. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 25

Light types • Directional light – – – a light infinitely far away from the scene all light rays are parallel for example, the sun has a homogeneous coordinate (w) of 0 for example (3. 0, 4. 0, 2. 0, 0. 0) 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 26

Light types • Positional light – – – a light inside the scene the light rays go in different directions for example, a table lamp has a homogeneous coordinate (w) of 1 for example (3. 0, 4. 0, 2. 0, 1. 0) 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 27

Light types • Spot light – a positional light with a restricted cone of illumination – GL_SPOT_CUTOFF determines the size of the cone, as in the following diagram GL_POSITION (position) GL_SPOT_CUTOFF (angle; 0 -90 degrees) GL_SPOT_DIRECTION (vector) 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 28

Light types – The intensity of the beam varies, depending on the angle between the GL_SPOT_DIRECTION and the light ray. Light rays along the spot direction are calculated at 100% intensity, while the light rays at the periphery of the cone are at lower intensities. – A cos curve raised to the GL_SPOT_EXPONENT power is used to calculated the intensity of light at various positions within the cone of illumination. All positions outside of the cone get 0% light 100% light 70% light 5% light 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 29

Positioning lights • • • Directional lights have no position, only direction The position and direction of a positional light source is multiplied by the current transformation matrix. It is very important that the camera of a scene be established before the position and direction of lights are specified The correct ordering of statements to place positional lights within a scene is – Clear buffer (gl. Clear()) – Clear transformations (gl. Load. Identity()) – Set up camera transformations – Set the light position (and direction if it is a spotlight) – Draw the objects in the scene. 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 30

Dr. Nate Robins 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 31

Notes • • Open. GL is a state machine. Therefore, if a parameter value never changes during the execution of a program, the value should only be set once. This increases the speed of rendering For example, if the linear attenuation of a light source never changes, set the attenuation once in your "init" function void init() { gl. Lightf(GL_LIGHT 0, GL_CONSTANT_ATTENTUATION, 1. 0); gl. Lightf(GL_LIGHT 0, GL_LINEAR_ATTENTUATION, 0. 0); gl. Lightf(GL_LIGHT 0, GL_QUADRATIC_ATTENTUATION, 0. 0); } 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 32

Notes • • The exception to this "state machine" concept is lighting. The position and direction of light sources are multiplied by the current transform when they are specified. The position and direction of a light source needs to be specified only once if the camera never moves (and the camera was set up before they are specified). Open. GL only applies the light model calculations to the vertices of a polygon. To increase the accuracy of the lighting effects, you must decrease the sizes of the polygons that define your objects. (Which makes rendering slower. ) 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 33

Notes • • • The shading calculations are very depend on a correct normal vector defined for each face. The face normal vector is expected to be defined in normalized form (of unit length). When an object is transformed by the current transformation matrix, both its vertices and normal vectors are transformed. If any scaling is part of the current transformation, the normal vectors will become unnormalized You need to enable the feature that will re-normalize the normal vectors if: – Your normal vectors were not initially specified in normal form – Your transformations include scaling – gl. Enable(GL_NORMALIZE); 10/28/2020 Computer Graphics, Lee Byung-Gook, Dongseo Univ. 34