【raviramamoorthi-Computer Graphics】OpenGL Shading: Fragment Shader

(代码来自于作业)

# version 120 

// Mine is an old machine.  For version 130 or higher, do 
// in vec4 color ;  
// in vec4 mynormal ; 
// in vec4 myvertex ;
// That is certainly more modern


varying vec4 color ;
varying vec3 mynormal ; 
varying vec4 myvertex ; 


uniform sampler2D tex ; 

uniform--  用于不经常更改的信息，用于顶点着色器和片元着色器

sampler2D     访问一个二维纹理

uniform int istex ; 

uniform int islight ; // are we lighting. 


// The commented code below hardcodes directions/colors
// Instead we use uniform variables set from opengl
// uniform vec3 lightdirn = vec3 (0.0,0.0,1.0) ; 
// uniform vec4 lightcolor = vec4(1.0,1.0,1.0,1.0) ; 


// Assume light 0 is directional, light 1 is a point light.  
// The actual light values are passed from the main OpenGL program. 
// This could of course be fancier.  My goal is to illustrate a simple idea. 

是如何交互的呢？在shaders.cpp将vertex和fragment shader 链接到一个新的program之后，主文件获得了initprogram的返回值。于是主文件从里头“取出”以下8个变量并建立映射，然后在主文件的display里将实际参数赋值给以下这些变量。

uniform vec3 light0dirn ; 

光线0的方向（线光源）

uniform vec4 light0color ; 

uniform vec4 light1posn ; 

光线1的位置（点光源）

uniform vec4 light1color ; 


// Now, set the material parameters.  These could be varying and/or bound to 
// a buffer.  But for now, I'll just make them uniform.  
// I use ambient, diffuse, specular, shininess as in OpenGL.  
// But, the ambient is just additive and doesn't multiply the lights.  

uniform vec4 ambient ; 

环境光

uniform vec4 diffuse ; 

漫反射强度（也可以认为是系数？传进来的vec4三个方向上的向量值都是一样哒，系数越大表现为物体表面越粗糙）

（0.2）（0.8）

uniform vec4 specular ; 

镜面反射强度（同上，系数越大，表现为高光部分越明亮）

（1.0）（2.0）

uniform float shininess ; 

镜面反射光的含聚指数（越大，则高光越集中，意思是镜面越光滑！）

这个函数其实就是在模拟phong illumination model的

vec4 ComputeLight (const in vec3 direction, const in vec4 lightcolor, const in vec3 normal, const in vec3 halfvec, const in vec4 mydiffuse, const in vec4 myspecular, const in float myshininess) {

这两句是在计算漫反射光。normal是法线方向，direction是反射光的方向

        float nDotL = dot(normal, direction)  ;         

        vec4 lambert = mydiffuse * lightcolor * max (nDotL, 0.0) ;  

这两句是在计算镜面反射光。因为是使用了改进的phong模型。

        float nDotH = dot(normal, halfvec) ; 
        vec4 phong = myspecular * lightcolor * pow (max(nDotH, 0.0), myshininess) ; 


        vec4 retval = lambert + phong ; 
        return retval ;            
}       


void main (void) 
{       
    if (istex > 0) gl_FragColor = texture2D(tex, gl_TexCoord[0].st) ; 
    else if (islight == 0) gl_FragColor = color ; 
    else { 
        // They eye is always at (0,0,0) looking down -z axis 
        // Also compute current fragment position and direction to eye 

        眼睛的起始位置：在（0,0,0）看向-z，即从天花板往下看~

const vec3 eyepos = vec3(0,0,0) ; 

将物体的位置矩阵计算一下。用一开始设定的世界坐标的各个vertex矩阵和建立的模型观察方式矩阵相乘。就理解为，物体的位置，就好

        vec4 _mypos = gl_ModelViewMatrix * myvertex ; 

将矩阵齐次化，目的是把w（第四个）分量变成1，这在之前的Lecture讨论过，目的是不让w分量影响到之后的计算

        vec3 mypos = _mypos.xyz / _mypos.w ; // Dehomogenize current location 

计算视线向量，注意这里是向量！所以是将视线从天花板拉到了预设的位置~

        vec3 eyedirn = normalize(eyepos - mypos) ; 

        // Compute normal, needed for shading. 

        // Simpler is vec3 normal = normalize(gl_NormalMatrix * mynormal) ; 

在上图我们看到一个三角形, 有一个法线向量和切线向量. 接下来的图显示当一个观察矩阵缩放的时候所显示的情景.(如调用glScale)

如果我们还是调用上面的代码的话.

注意: 当观察矩阵各方向尺寸不一致时,应当预先保存法线的方向, 虽然法线的长度会变化,但是单元化很易修复
在上图, 观察矩阵影响到所有的顶点以及法线. 很明显这个结果是错误的. 法线并不垂直于切线.

所以现在我们得知并不能将观察矩阵应用于所有的法线. 所以我们应当应用怎样的矩阵呢?

注意到T*N = 0. 所以在视觉空间中, 两者还应当是垂直的, 保证转换后的T'*N' = 0.
假设矩阵G是转换法线N的矩阵.T则乘观察矩阵左上的3*3矩阵M(T是一个向量, 令w为0).式子如下:


点积可以转换成向量积, 如下


由于N"T = 0, 所以我们猜想 
(I为单位矩阵)
所以

因为N‘=GN，因此就有了下面的公式：

        vec3 _normal = (gl_ModelViewMatrixInverseTranspose*vec4(mynormal,0.0)).xyz ; 
        vec3 normal = normalize(_normal) ; 


        // Light 0, directional

        vec3 direction0 = normalize (light0dirn) ; 

phong 光照模型中，必须计算 的V和R的点积的值值，其中 R为反射光线方向单位向量， V为视线方向单位向量，但是在 Blinn-phong 光照模型中，用N dot H 的值取代了V dot R 。 Blinn-phong 光照模型公式为：

                    

其中 N是入射点的单位法向量， H是“光入射方向L 和视点方向V 的中间向量”，通常也称之为半角向量。 注意：半角向量被广泛用于各类光照模型，原因不但在于半角向量蕴含的信息价值，也在于计算半角向量是一件简单、耗时不多的工作。

因此这里是两个向量相加，生成半角向量~        vec3 half0 = normalize (direction0 + eyedirn) ; 
        vec4 col0 = ComputeLight(direction0, light0color, normal, half0, diffuse, specular, shininess) ;


        // Light 1, point 

        vec3 position = light1posn.xyz / light1posn.w ; 

计算点光源到物体的向量表示。

        vec3 direction1 = normalize (position - mypos) ; // no attenuation 

同上

        vec3 half1 = normalize (direction1 + eyedirn) ;  
        vec4 col1 = ComputeLight(direction1, light1color, normal, half1, diffuse, specular, shininess) ;
        

       最后每一个Pixel上的颜色，是环境光（传进来的，每一点都需要加上）+漫反射光+镜面反射光

 gl_FragColor = ambient + col0 + col1 ; 

        }
}