• Android OpenGLES3.0 开发 ：光照基础

    1.OpenGLES 基础光照模型

    OpenGLES 目前还无法模拟现实世界的复杂光照效果，为了在效果要求和实现难度之间做一个平衡，往往采用一些简化的模型来模拟光照效果。冯氏光照模型(Phong Lighting Model)便是其中常用的一个光照模型，它由三种元素光组成，分别是：

    • 环境光(Ambient Lighting)
    • 散射光(Diffuse Lighting)
    • 镜面光(Specular Lighting)。
    2.环境光

    环境光表示从四面八方照射到物体上且各个方向都均匀的光，不依赖于光源位置，没有方向性。

    要把环境光照添加到场景里：光的颜色×很小常量环境因子×物体的颜色，然后使用它作为片段的颜色

    float ambientStrength = 0.2;                //环境光强度因子
ambient = ambientStrength * lightColor;     //强度因子*光的颜色=环境光强度

    • 1
    • 2
    3.散射光

    散射光表示从物体表面向各个方向均匀反射的光。散射光的强度与入射光的强度及入射角密切相关，所以当光源位置发生变化，散射光效果也会发生明显变化。

    散射光最终强度 = 材质反射系数 × 散射光强度 × max(cos(入射角)，0)

    其中入射角表示：当前片段光源照射方向与法向量之间的夹角。

    float diffuseStrength = 0.6;                                             //材质反射系数
vec3 unitNormal = normalize(vec3(u_ModelMatrix * vec4(a_normal, 1.0)));   //对一个向量进行标准化
vec3 lightDir = normalize(lightPos - fragPos);                        //归一化  将光的位置-片元的位置  给归一化了
float diff = max(dot(unitNormal, lightDir), 0.0);                     //dot 电乘得到的是夹角
diffuse = diffuseStrength * diff * lightColor;                        //散射光强度

    • 1
    • 2
    • 3
    • 4
    • 5
    4.镜面光

    镜面光是由光滑物体表面反射的方向比较集中的光，镜面光强度不仅依赖于入射光与法向量的夹角，也依赖于观察者的位置。

    镜面光最终强度 = 材质镜面亮度因子 × 镜面光强度 × max(cos(反射光向量与视线方向向量夹角)，0)

    // Specular 镜面光  镜面光最终强度 = 材质镜面亮度因子 × 镜面光强度 × max(cos(反射光向量与视线方向向量夹角)，0)
float specularStrength = 0.8;                                   //材质镜面亮度因子
vec3 viewDir = normalize(viewPos - fragPos);                    // 将光的位置-片元的位置  给归一化了，得到一个三维向量
vec3 reflectDir = reflect(-lightDir, unitNormal);               //光的折射向量
float spec = pow(max(dot(unitNormal, reflectDir), 0.0), 16.0);  //前边值得16次方
specular = specularStrength * spec * lightColor;
v_texCoord = a_texCoord;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    5.绘制一个自动旋转的立方体，旋转过程中光线不断在变化
    void MSBasicLightSample::PaintGL() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    m_angle += 0.02f;
   
    glm::mat4 modelMat = glm::mat4(1.0f);  //模型矩阵
    modelMat = glm::scale(modelMat, glm::vec3(0.8f, 0.8f, 0.8f));
    modelMat = glm::rotate(modelMat, m_angle, glm::vec3(1.0f, 0.0f, 0.0f));
    modelMat = glm::rotate(modelMat, m_angle, glm::vec3(0.0f, 1.0f, 0.0f));
    modelMat = glm::translate(modelMat, glm::vec3(0.0f, 0.0f, 0.0f));

    glm::mat4 projection =glm::perspective(glm::radians(60.0f), (float) 9 / (float) 18, 0.1f,
                                           1000.0f);

    // View matrix
    glm::mat4 ViewMat = glm::lookAt(
            glm::vec3(-3, 0, 3), // Camera is at (0,0,1), in World Space
            glm::vec3(0, 0, 0), // and looks at the origin
            glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
    );


    glm::mat4 mvpMatrix = projection * ViewMat * modelMat;

    m_pOpenGLShader->Bind();
    m_pOpenGLShader->SetUniformValue("u_MVPMatrix", mvpMatrix);
    m_pOpenGLShader->SetUniformValue("u_ModelMatrix", modelMat);

    m_pOpenGLShader->SetUniformValue("lightColor", glm::vec3(1.0f, 1.0f, 1.0f));
    m_pOpenGLShader->SetUniformValue("lightPos", glm::vec3(-2.0f, 0.0f, 2.0f));
    m_pOpenGLShader->SetUniformValue("viewPos", glm::vec3(-3.0f, 0.0f, 3.0f));

    m_pVAO->Bind();

    for (int i = 0; i < 6; i++) {
        glActiveTexture(GL_TEXTURE0);
        if (i==4){
            glBindTexture(GL_TEXTURE_2D, m_texID[i+1]);
        }else{
            glBindTexture(GL_TEXTURE_2D, m_texID[i]);
        }
        int offset = i * 6 * sizeof(unsigned short);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void *) offset);
        glBindTexture(GL_TEXTURE_2D, 0);
    }


    m_pOpenGLShader->Release();
    m_pVAO->Release();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • modelMat:模型矩阵用于控制旋转、缩放、平移等效果
    • ViewMat：观察者矩阵，表示观察者的位置
    • projection：透视矩阵区别于正交矩阵，透视矩阵有近大远小的视觉效果，正交矩阵则没有。

    将MVP矩阵、模型矩阵、光的位置、光的颜色与观察者的位置传给shader。

    顶点着色器

    #version 300 es
precision mediump float;
layout(location = 0) in vec4 a_position;
layout(location = 1) in vec2 a_texCoord;
layout(location = 2) in vec3 a_normal;

uniform mat4 u_MVPMatrix;       //MVP矩阵
uniform mat4 u_ModelMatrix;     //模型矩阵
uniform vec3 lightPos;          //光的位置
uniform vec3 lightColor;      //光的颜色
uniform vec3 viewPos;         //观察者的位置
out vec2 v_texCoord;         //输出的材质
out vec3 ambient;           //环境光
out vec3 diffuse;             //散射光
out vec3 specular;          //镜面光


void main() {
    gl_Position = u_MVPMatrix * a_position;   //投影变换之后，输出的是gl_Position,也就是说你最终画在屏幕里面的哪个位置
    vec3 fragPos = vec3(u_ModelMatrix * a_position);  //当前片元坐标：也就是通过旋转等变换之后的坐标

    // Ambient  环境光 要把环境光照添加到场景里，只需用光的颜色乘以一个(数值)很小常量环境因子，再乘以物体的颜色，然后使用它作为片段的颜色
    float ambientStrength = 0.2;                //环境光强度因子
    ambient = ambientStrength * lightColor;     //强度因子*光的颜色=环境光强度

    // Diffuse 散射光  散射光最终强度 = 材质反射系数 × 散射光强度 × max(cos(入射角)，0)
    float diffuseStrength = 0.6;                                             //材质反射系数
    vec3 unitNormal = normalize(vec3(u_ModelMatrix * vec4(a_normal, 1.0)));   //对一个向量进行标准化
    vec3 lightDir = normalize(lightPos - fragPos);                        //归一化  将光的位置-片元的位置  给归一化了，得到一个三维向量
    float diff = max(dot(unitNormal, lightDir), 0.0);                     //dot 电乘得到的是夹角
    diffuse = diffuseStrength * diff * lightColor;                        //散射光强度

    // Specular 镜面光  镜面光最终强度 = 材质镜面亮度因子 × 镜面光强度 × max(cos(反射光向量与视线方向向量夹角)，0)
    float specularStrength = 0.8;                                   //材质镜面亮度因子
    vec3 viewDir = normalize(viewPos - fragPos);                    // 将光的位置-片元的位置  给归一化了，得到一个三维向量
    vec3 reflectDir = reflect(-lightDir, unitNormal);               //光的折射向量
    float spec = pow(max(dot(unitNormal, reflectDir), 0.0), 16.0);  //前边值得16次方
    specular = specularStrength * spec * lightColor;
    v_texCoord = a_texCoord;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    顶点着色器根据传入的光的数据以及位置信息计算光线的强度，注释写的比较清楚。

    片元着色器

    #version 300 es
precision mediump float;

in vec2 v_texCoord;
in vec3 ambient;
in vec3 diffuse;
in vec3 specular;
layout(location = 0) out vec4 outColor;
uniform sampler2D s_TextureMap;

void main() {
    vec4 objectColor = texture(s_TextureMap, v_texCoord);
    vec3 finalColor = (ambient + diffuse + specular) * vec3(objectColor);
    outColor = vec4(finalColor, 1.0);    //增加A 通道
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    片元着色器：将顶点着色器计算的光线直接跟采样器得到的颜色相乘得到了最终的颜色

  • 相关阅读:
    Unity中UI Shader遮罩RectMask2D
    基于springboot的校园食堂订餐系统
    ​ISP算法及架构分析介绍
    Spring声明式基于注解的缓存（2-实践篇）
    聊聊Java的垃圾回收机制
    操作系统知识回顾（更新中，自用）
    DW网页作业成品下载后导入Dreamweaver如何新建站点及导出站点
    JAVA 获得特定格式时间
    vulnhub靶场之Beelzebub
    如何将本地项目上传到GitHub
  • 原文地址：https://blog.csdn.net/u014078003/article/details/127970571