GPU编程之GLSL（六）——着色与逐顶点光照

最新推荐文章于 2024-03-05 17:10:15 发布

Sun7_She

最新推荐文章于 2024-03-05 17:10:15 发布

阅读量1.7k

点赞数

分类专栏： GPU编程文章标签： GLSL gpu 编程 c++

本文链接：https://blog.csdn.net/sun7_she/article/details/38556137

版权

GPU编程专栏收录该内容

18 篇文章 1 订阅

订阅专栏

=======================================基础知识=============================================================

有一个疑问：

顶点shader和片段shader都可以改变颜色，顶点shader可以改变物体的形状，那么片段shader可以改变物体形状么？他们的本质区别是什么呢

顶点shader：可以在此改变顶点坐标，即改变物体形状

最简单的语句即为：

void main()  
{  
    gl_Position =ftransform();  
}

片段shader：可以在此改变物体颜色

以下程序可以将物体设置为淡蓝色

void main()  
{  
    gl_FragColor =vec4(0.4,0.4,0.8,1.0);  
}

GLSL获取OpenGL颜色信息方式如下：

顶点着色器：

void main()  
{  
    gl_FrontColor =gl_Color;  
    gl_Position =ftransform();  
}

片段着色器：

void main()  
{  
    gl_FragColor = gl_Color;  
}

因为变量已经定义好了其代表的信息

1、OpenGL程序通过glColor传送颜色信息。

2、顶点shader通过属性gl_Color接收颜色值。

3、顶点shader计算正面和反面的颜色，然后分别保存在gl_FrontColor和gl_BackColor中。

4、片断shader接收易变变量gl_Color中存储的插值产生的颜色，由当前图元的方向决定颜色是gl_FrontColor还是gl_BackColor插值产生的。

5、片断shader根据易变变量gl_Color设置gl_FragColor。

我们不仅可以改变物体的颜色，也可以改变物体的形状，如果想要使物体成为扁平的3D模型，则使用扁平shader

void main(void)  
{  
    vec4 v = vec4(gl_Vertex);  
    v.z = 0.0;  
  
    gl_Position =gl_ModelViewProjectionMatrix * v;  
}

与其他编程方式一样，可以对Z坐标或是其他坐标做其他方式的处理，如添加变量使之可以形成动画等，但是在GLSL中不可以有变量，所用到的变量需要从OpenGL中定义好并传输过来，如：

uniform float time;

那么如何在OpenGL中设置变量呢，就需要用到如下语句：

loc =glGetUniformLocation(p,"time");

其中time是与shader中定义的变量名称相同，

之后在OpenGL中改变time变量，即用类似下边的语句即可：

glUniform1f(loc, time);  
time+=0.01;

=======================================卡通着色=============================================================

逐顶点计算色调强度（intensity）的方法

lightDir是由OpenGL程序提供的，所以我们可以假定它传到shader之前已经归一化了。只有光线方向改变时，才需要重新计算归一化。此外OpenGL程序传过来的法线gl_Normal也应该是经过归一化的。

uniform vec3 lightDir;

GLSL提供dot函数来计算两个向量的夹角余弦值

intensity = dot(lightDir, gl_Normal);

最后顶点要做的就是变换顶点坐标。顶点shader的完整代码如下：

uniform vec3 lightDir;  
varying float intensity;  
  
void main()  
{  
    intensity = dot(lightDir,gl_Normal);  
    gl_Position = ftransform();  
}

如果想使用OpenGL中的变量作为光的方向，那么可以用gl_LightSource[0].position代替一致变量lightDir

即在main函数第一行加上：

vec3 lightDir = normalize(vec3(gl_LightSource[0].position));

可以将茶壶设置不同的颜色显示，并拥有立体效果，余弦大于0.95时使用最亮的颜色，小于0.25时使用最暗的颜色。得到这个颜色后只需要再将其写入gl_FragColor即可，片断shader的完整代码如下：

varying float intensity;  
  
void main()  
{  
    vec4 color;  
    if (intensity > 0.95)  
  
        color = vec4(1.0,0.5,0.5,1.0);  
    else if (intensity > 0.5)  
        color = vec4(0.6,0.3,0.3,1.0);  
    else if (intensity > 0.25)  
        color = vec4(0.4,0.2,0.2,1.0);  
    else  
        color = vec4(0.2,0.1,0.1,1.0);  
    gl_FragColor = color;  
}

把计算移到片断shader中

顶点shader的代码：

varying vec3 normal;  
  
void main()  
{  
    normal = gl_Normal;  
    gl_Position = ftransform();  
}

片段shader的代码——注意第7行，对法线归一化

uniform vec3 lightDir;  
varying vec3 normal;  
  
void main()  
{  
    float intensity;  
    vec4 color;  
    intensity = dot(lightDir,normalize(normal));  
  
    if (intensity > 0.95)  
        color = vec4(1.0,0.5,0.5,1.0);  
    else if (intensity > 0.5)  
        color = vec4(0.6,0.3,0.3,1.0);  
    else if (intensity > 0.25)  
        color = vec4(0.4,0.2,0.2,1.0);  
    else  
        color = vec4(0.2,0.1,0.1,1.0);  
    gl_FragColor = color;  
}

访问OpenGL中光源的方向：

OpenGL中定义light0为方向光

float lpos[4] = {1.0,0.0,1.0,0.0};
glLightfv(GL_LIGHT0, GL_POSITION, lpos);

而GLSL已经有了这样的结构体：

struct gl_LightSourceParameters  
{  
    vec4 ambient;  
    vec4 diffuse;  
    vec4 specular;  
    vec4 position;  
    ...  
};  
  
uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];

我们只需调用即可

因此顶点shader为：

varying vec3 normal;  
  
void main()  
{  
    normal = gl_NormalMatrix * gl_Normal;  
    gl_Position = ftransform();  
}

片段shader为：

varying vec3 normal;  
  
void main()  
{  
    float intensity;  
    vec4 color;  
    vec3 n = normalize(normal);  
    intensity = dot(vec3(gl_LightSource[0].position),n);  
  
    if (intensity > 0.95)  
        color = vec4(1.0,0.5,0.5,1.0);  
    else if (intensity > 0.5)  
        color = vec4(0.6,0.3,0.3,1.0);  
    else if (intensity > 0.25)  
        color = vec4(0.4,0.2,0.2,1.0);  
    else  
        color = vec4(0.2,0.1,0.1,1.0);  
    gl_FragColor = color;  
}

=======================================逐顶点光照=========================================================

在了解光照之前，我们需要明确在GLSL中我们可以使用的变量有哪些：

首先是光照参数：

struct gl_LightSourceParameters  
{  
    vec4 ambient;  
    vec4 diffuse;  
    vec4 specular;  
    vec4 position;  
    vec4 halfVector;  
    vec3 spotDirection;  
    float spotExponent;  
    float spotCutoff; // (range: [0.0,90.0], 180.0)  
    float spotCosCutoff; // (range: [1.0,0.0],-1.0)  
    float constantAttenuation;  
    float linearAttenuation;  
    float quadraticAttenuation;  
};  
  
uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];  
struct gl_LightModelParameters  
{  
    vec4 ambient;  
};  
uniform gl_LightModelParameters gl_LightModel;

然后是材质参数：

struct gl_MaterialParameters  
{  
    vec4 emission;  
    vec4 ambient;  
    vec4 diffuse;  
    vec4 specular;  
    float shininess;  
};  
  
uniform gl_MaterialParameters gl_FrontMaterial;  
uniform gl_MaterialParameters gl_BackMaterial;

这里我们就不讲过多的理论知识了，毕竟编程还是比较重要的，通过看代码，我们来学习一下各个函数的使用方法：

我们需要知道的是计算散射光的公式为：

反射光强度=光源的散射成分(gl_LightSource[0].difuse) * 材质的散射系数(gl_FrontMaterial.diffuse) * cos(theta)

其中：theta为光线与法向的夹角。

因此顶点shader代码为：

void main()  
{  
    vec3 normal, lightDir;  
    vec4 diffuse;  
    float NdotL;  
  
    /* 将gl_Normal转换到视口矩阵并归一化*/  
    normal = normalize(gl_NormalMatrix * gl_Normal);  
    /* 归一化光线方向*/  
    lightDir = normalize(vec3(gl_LightSource[0].position));  
    /* 计算光线与法线夹角余弦 */  
    NdotL = max(dot(normal, lightDir), 0.0);  
    /* 计算散射光，是由下边两个公式共同计算得到*/  
    diffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;  
    gl_FrontColor =  NdotL * diffuse;  
  
    gl_Position = ftransform();  
}

片段shader代码为：

void main()  
{  
    gl_FragColor = gl_Color;  
}

此时我们只加入了散射光，并没有环境光，物体的颜色并不理想，在此引入环境光的计算方法：

只需在片段shader中加入（最后一行用于替换）以下公式即可：

 
    ambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;  
    globalAmbient = gl_FrontMaterial.ambient * gl_LightModel.ambient;  
    gl_FrontColor =  NdotL * diffuse + globalAmbient + ambient;

镜面反射光：

  
if (NdotL > 0.0)  
{  
    // normalize the half-vector, and then compute the  
    // cosine (dot product) with the normal  
    NdotHV = max(dot(normal, gl_LightSource[0].halfVector.xyz),0.0);  
    specular = gl_FrontMaterial.specular * gl_LightSource[0].specular *  
            pow(NdotHV,gl_FrontMaterial.shininess);  
}

最后的总的光计算公式改为：

gl_FrontColor = globalAmbient + NdotL * diffuse + ambient + specular;

内容参考自 http://blog.csdn.net/racehorse?viewmode=contents

公式来自《OpenGL编程指南》中“和光照有关的数学知识”一章

Sun7_She

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
GPU编程之GLSL（六）——着色与逐顶点光照

=======================================基础知识=============================================================有一个疑问：顶点shader和片段shader都可以改变颜色，顶点shader可以改变物体的形状，那么片段shader可以改变物体形状么？他们的本质区别是什么呢顶
复制链接

扫一扫