重新自学学习openGL 之光照多光源

其实前面我们已经将光照的基本知识学习完毕了.本章主要学习的是如何在shader中使用多个光源对物体进行渲染.

本章主要因为不涉及新的知识点,只是举例说明多光源的应用

例子

模拟一个类似太阳的定向光(Directional Light)光源，四个分散在场景中的点光源(Point Light)，以及一个手电筒(Flashlight)。

设计

为了在场景中使用多个光源，我们希望将光照计算封装到GLSL函数中。这样做的原因是，每一种光源都需要一种不同的计算方法，而一旦我们想对多个光源进行光照计算时，代码很快就会变得非常复杂。如果我们只在main函数中进行所有的这些计算，代码很快就会变得难以理解。

GLSL中的函数和C函数很相似，它有一个函数名、一个返回值类型，如果函数不是在main函数之前声明的，我们还必须在代码文件顶部声明一个原型。我们对每个光照类型都创建一个不同的函数：定向光、点光源和聚光。

当我们在场景中使用多个光源时，通常使用以下方法：我们需要有一个单独的颜色向量代表片段的输出颜色。对于每一个光源，它对片段的贡献颜色将会加到片段的输出颜色向量上。所以场景中的每个光源都会计算它们各自对片段的影响，并结合为一个最终的输出颜色。大体的结构会像是这样：

void main()
{
    vec3 norm = normalize(normal);
    vec3 viewDir = normalize(viewPos - FragPos);
//    ///平行光
    vec3 result = CalcDirLight(dirLight, norm, viewDir);
//    // 点光源
    for(int i = 0; i < NR_POINT_LIGHTS; I++)
        result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);
////     聚光
    result +=CalcSpotLight(spotLight, norm, FragPos, viewDir);;
    gl_FragColor = vec4(result, 1.0);
 
}

实际的代码对每一种实现都可能不同，但大体的结构都是差不多的。我们定义了几个函数，用来计算每个光源的影响，并将最终的结果颜色加到输出颜色向量上。例如，如果两个光源都很靠近一个片段，那么它们所结合的贡献将会形成一个比单个光源照亮时更加明亮的片段。

定向光

我么需要在片段着色器中定义一个函数来计算定向光对相应片段的贡献：它接受一些参数并计算一个定向光照颜色。
首先，我们需要定义一个定向光源最少所需要的变量。我们可以将这些变量储存在一个叫做DirLight的结构体中，并将它定义为一个uniform。

struct DirLight {
    vec3 direction;

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};  
uniform DirLight dirLight;

接下来我们可以将dirLight传入一个有着一下原型的函数。

vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir);

我们在该函数中实现平行光

vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
{
    vec3 diffuseT =vec3(texture2D(material.diffuse,v_texture));
    vec3 specularT =vec3(texture2D(material.specular,v_texture));
    
    ///环境光
    vec3 ambient = light.ambient * diffuseT;
    
    // 漫反射
    vec3 lightDir = normalize(-light.direction);
    float diff = max(dot(normal, lightDir), 0.0);
    vec3 diffuse = light.diffuse * (diff * diffuseT);
    
    // 镜面光
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess*128.0);
    vec3 specular = light.specular * (spec * specularT);
    
    return( ambient + diffuse + specular);
}

传值核心代码

//绑定shader
weakSelf.bindObject->uniforms[MLS_UniformLocationDirLightDirection] = glGetUniformLocation(self.shader.program, "dirLight.direction");
        weakSelf.bindObject->uniforms[MLS_UniformLocationDirLightAmbient] = glGetUniformLocation(self.shader.program, "dirLight.ambient");
        weakSelf.bindObject->uniforms[MLS_UniformLocationDirLightDiffuse] = glGetUniformLocation(self.shader.program, "dirLight.diffuse");
        weakSelf.bindObject->uniforms[MLS_UniformLocationDirLightSpecular] = glGetUniformLocation(self.shader.program, "dirLight.specular");

//传值shader 
  MLS_DirLight dirlight ;

    dirlight.direction = GLKVector3Make(-0.2f, -1.0f, -0.3f);
    dirlight.ambient =GLKVector3Make(0.3f, 0.24f, 0.14f);
    dirlight.diffuse =GLKVector3Make( 0.7f, 0.42f, 0.26f);
    dirlight.specular =GLKVector3Make(0.5f, 0.5f, 0.5f);
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationDirLightDirection], 1, &dirlight.direction);
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationDirLightAmbient], 1, &dirlight.ambient);
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationDirLightSpecular], 1, &dirlight.specular);
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationDirLightDiffuse], 1, &dirlight.diffuse);

只实现该光源的屏幕截图

点光源

和定向光一样，我们也希望定义一个用于计算点光源对相应片段贡献，以及衰减，的函数。同样，我们定义一个包含了点光源所需所有变量的结构体：

struct PointLight {
    vec3 position;

    float constant;
    float linear;
    float quadratic;

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};  
#define NR_POINT_LIGHTS 4
uniform PointLight pointLights[NR_POINT_LIGHTS];

你可以看到，我们在GLSL中使用了预处理指令来定义了我们场景中点光源的数量。接着我们使用了这个NR_POINT_LIGHTS常量来创建了一个PointLight结构体的数组。GLSL中的数组和C数组一样，可以使用一对方括号来创建。现在我们有四个待填充数据的PointLight结构体。

我们也可以定义一个大的结构体（而不是为每种类型的光源定义不同的结构体），包含所有不同种光照类型所需的变量，并将这个结构体用到所有的函数中，只需要忽略用不到的变量就行了。然而，我个人觉得当前的方法会更直观一点，不仅能够节省一些代码，而且由于不是所有光照类型都需要所有的变量，这样也能节省一些内存。

点光源函数的原型如下：

vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir);

该函数实现

vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
{
    vec3 diffuseT =vec3(texture2D(material.diffuse,v_texture));
    vec3 specularT =vec3(texture2D(material.specular,v_texture));
    
    vec3 lightDir = normalize(light.position - FragPos);

    ///环境光
    vec3 ambient = light.ambient * diffuseT;
    
    // 漫反射
    float diff = max(dot(normal, lightDir), 0.0);
    vec3 diffuse = light.diffuse * (diff * diffuseT);
    
    // 镜面光
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess*128.0);
    vec3 specular = light.specular * (spec * specularT);
    
    
    float distance    = length(light.position - fragPos);
    float attenuation = 1.0 / (light.constant + light.linear * distance +
                               light.quadratic * (distance * distance));
    
    ambient  *= attenuation;
    diffuse   *= attenuation;
    specular *= attenuation;
    return (ambient + diffuse + specular);

}

这些功能抽象到这样一个函数中的优点是，我们能够不用重复的代码而很容易地计算多个点光源的光照了。在main函数中，我们只需要创建一个循环，遍历整个点光源数组，对每个点光源调用CalcPointLight就可以了。

核心传值代码

// 绑定
        ///点光 0
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroPos] = glGetUniformLocation(self.shader.program, "pointLights[0].position");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroAmbient] = glGetUniformLocation(self.shader.program, "pointLights[0].ambient");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroDiffuse] = glGetUniformLocation(self.shader.program, "pointLights[0].diffuse");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroSpecular] = glGetUniformLocation(self.shader.program, "pointLights[0].specular");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroConstant] = glGetUniformLocation(self.shader.program, "pointLights[0].constant");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroLinear] = glGetUniformLocation(self.shader.program, "pointLights[0].linear");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroQuadratic] = glGetUniformLocation(self.shader.program, "pointLights[0].quadratic");
        ///点光 1
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightOnePos] = glGetUniformLocation(self.shader.program, "pointLights[1].position");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightOneAmbient] = glGetUniformLocation(self.shader.program, "pointLights[1].ambient");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightOneDiffuse] = glGetUniformLocation(self.shader.program, "pointLights[1].diffuse");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightOneSpecular] = glGetUniformLocation(self.shader.program, "pointLights[1].specular");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightOneConstant] = glGetUniformLocation(self.shader.program, "pointLights[1].constant");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightZeroLinear] = glGetUniformLocation(self.shader.program, "pointLights[1].linear");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightOneQuadratic] = glGetUniformLocation(self.shader.program, "pointLights[1].quadratic");
        ///点光 2
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightTwoPos] = glGetUniformLocation(self.shader.program, "pointLights[2].position");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightTwoAmbient] = glGetUniformLocation(self.shader.program, "pointLights[2].ambient");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightTwoDiffuse] = glGetUniformLocation(self.shader.program, "pointLights[2].diffuse");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightTwoSpecular] = glGetUniformLocation(self.shader.program, "pointLights[2].specular");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightTwoConstant] = glGetUniformLocation(self.shader.program, "pointLights[2].constant");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightTwoLinear] = glGetUniformLocation(self.shader.program, "pointLights[2].linear");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightTwoQuadratic] = glGetUniformLocation(self.shader.program, "pointLights[2].quadratic");
        ///点光 3
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightThreePos] = glGetUniformLocation(self.shader.program, "pointLights[3].position");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightThreeAmbient] = glGetUniformLocation(self.shader.program, "pointLights[3].ambient");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightThreeDiffuse] = glGetUniformLocation(self.shader.program, "pointLights[3].diffuse");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightThreeSpecular] = glGetUniformLocation(self.shader.program, "pointLights[3].specular");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightThreeConstant] = glGetUniformLocation(self.shader.program, "pointLights[3].constant");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightThreeLinear] = glGetUniformLocation(self.shader.program, "pointLights[3].linear");
        weakSelf.bindObject->uniforms[MLS_UniformLocationPointLightThreeQuadratic] = glGetUniformLocation(self.shader.program, "pointLights[3].quadratic");

//传值
   GLKVector3 pointLightPositions[] = {
       GLKVector3Make( 0.7f,  0.2f,  2.0f),
        GLKVector3Make( 2.3f, -3.3f, -4.0f),
       GLKVector3Make(-4.0f,  2.0f, -12.0f),
        GLKVector3Make( 0.0f,  0.0f, -3.0f)
    };
    MLS_PointLight pointLight[4];
    for (int i=0; i<4; i++) {
        pointLight[i].position= pointLightPositions[I];
        pointLight[i].ambient = GLKVector3Make(0.05f, 0.05f, 0.05f);;
        pointLight[i].diffuse = GLKVector3Make(0.8f, 0.8f, 0.8f);
        pointLight[i].specular = GLKVector3Make( 1.0f, 1.0f, 1.0f);
        pointLight[i].constant = 1.0;
        pointLight[i].linear = 0.09;
        pointLight[i].quadratic = 0.032;
    }
 
    for (int i=0; i<4; i++) {
        glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationPointLightZeroPos+i*7], 1, &pointLight[i].position);
        glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationPointLightZeroAmbient+i*7], 1, &pointLight[i].ambient);

        glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationPointLightZeroDiffuse+i*7], 1, &pointLight[i].diffuse);

        glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationPointLightZeroSpecular+i*7], 1, &pointLight[i].specular);

        glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationPointLightZeroConstant+i*7], 1, &pointLight[i].constant);

        glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationPointLightZeroLinear+i*7], 1, &pointLight[i].linear);
        glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationPointLightZeroQuadratic+i*7], 1, &pointLight[i].quadratic);
    }

只有点光源四个灯的效果

聚光

和定向光一样，我们定义一个包含了点光源所需所有变量的结构体：


struct SpotLight {
    vec3 position;
    vec3 direction;
    float cutOff;
    float outerCutOff;
    
    float constant;
    float linear;
    float quadratic;
    
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};
uniform SpotLight spotLight;

聚光函数的原型如下：

vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir);

该函数实现如下

vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
{
    vec3 diffuseT =vec3(texture2D(material.diffuse,v_texture));
    vec3 specularT =vec3(texture2D(material.specular,v_texture));
    
    //环境光
    vec3 ambient = light.ambient * diffuseT;
    vec3 lightDir = normalize(light.position - FragPos);

    // 漫反射
    float diff = max(dot(normal, lightDir), 0.0);
    vec3 diffuse = light.diffuse * (diff * diffuseT);
    
    // 镜面光
    vec3 reflectDir = reflect(-lightDir, normal);
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
    vec3 specular = light.specular * (spec * specularT);
    
    // spotlight (soft edges)
    float theta = dot(lightDir, normalize(-light.direction));
    float epsilon = (light.cutOff - light.outerCutOff);
    float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
    diffuse  *= intensity;
    specular *= intensity;
    
    // attenuation
    float distance    = length(light.position - FragPos);
    float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));
    
    // ambient  *= attenuation; // remove attenuation from ambient, as otherwise at large distances the light would be darker inside than outside the spotlight due the ambient term in the else branche
    diffuse   *= attenuation;
    specular *= attenuation;
    
    return (ambient + diffuse + specular);
}

核心传值代码

///绑定
   weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightPos] = glGetUniformLocation(self.shader.program, "spotLight.position");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightDirection] = glGetUniformLocation(self.shader.program, "spotLight.direction");
        
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightAmbient] = glGetUniformLocation(self.shader.program, "spotLight.ambient");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightDiffuse] = glGetUniformLocation(self.shader.program, "spotLight.diffuse");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightSpecular] = glGetUniformLocation(self.shader.program, "spotLight.specular");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightConstant] = glGetUniformLocation(self.shader.program, "spotLight.constant");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightLinear] = glGetUniformLocation(self.shader.program, "spotLight.linear");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightQuadratic] = glGetUniformLocation(self.shader.program, "spotLight.specular");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightcutOff] = glGetUniformLocation(self.shader.program, "spotLight.cutOff");
        weakSelf.bindObject->uniforms[MLS_UniformLocationSpotLightouterCutOff] = glGetUniformLocation(self.shader.program, "spotLight.outerCutOff");
        
///传值
 MLS_SpotLight spotLight;
    spotLight.position =  GLKVector3Make(0.0f, 0.0f, 3.0f);
    spotLight.ambient  =GLKVector3Make( 0.0f, 0.0f, 0.0f);
    spotLight.diffuse  =GLKVector3Make(1.0f, 1.0f, 1.0f);
    spotLight.specular  =GLKVector3Make(1.0,1.0,1.0);
    spotLight.constant = 1.0;
    spotLight.linear = 0.09f    ;
    spotLight.quadratic = 0.032f;
    //     0.0f, 0.0f, 3.0f
    const float YAW         = -90.0f;
    const float PITCH       =  0.0f;
    GLKVector3 front;
    front.x = cos(MLS_radians(YAW)) * cos(MLS_radians(PITCH));
    front.y = sin(MLS_radians(PITCH));
    front.z = sin(MLS_radians(YAW)) * cos(MLS_radians(PITCH));
    front = GLKVector3Normalize(front);
    spotLight.direction = front;
    spotLight.cutOff = cos(MLS_radians(12.5));
    spotLight.outerCutOff =cos(MLS_radians(15.0));
    
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightPos], 1, &spotLight.position);
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightDirection], 1, &spotLight.direction);

    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightAmbient], 1, &spotLight.ambient);
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightSpecular], 1, &spotLight.specular);
    glUniform3fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightDiffuse], 1, &spotLight.diffuse);
    glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightConstant], 1, &spotLight.constant);
    glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightLinear], 1, &spotLight.linear);
    glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightQuadratic], 1, &spotLight.quadratic);
    glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightcutOff], 1, &spotLight.cutOff);
    glUniform1fv(self.bindObject->uniforms[MLS_UniformLocationSpotLightouterCutOff], 1, &spotLight.outerCutOff);

只实现聚光灯效果图片

光源合并

每个光源类型都将它们的贡献加到了最终的输出颜色上，直到所有的光源都处理完了。最终的颜色包含了场景中所有光源的颜色影响所合并的结果

void main()
{
    vec3 norm = normalize(normal);
    vec3 viewDir = normalize(viewPos - FragPos);
    vec3 result = vec3(0.0);
   ///平行光
     result += CalcDirLight(dirLight, norm, viewDir);
    // 点光源
    for(int i = 0; i < NR_POINT_LIGHTS; I++)
        result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);
//     聚光
    result +=CalcSpotLight(spotLight, norm, FragPos, viewDir);;
//
    gl_FragColor = vec4(result, 1.0);
   
}

最终效果

旋转效果如下

发现点光源是卡顿的主要原因.暂时不解决

源码地址对应的demo是OpenGLZeroStudyDemo(7)-光照
 参考博客

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 215,384评论 6赞 497
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,845评论 3赞 391
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 161,148评论 0赞 351
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,640评论 1赞 290
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,731评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,712评论 1赞 294
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,703评论 3赞 415
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,473评论 0赞 270
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,915评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,227评论 2赞 331
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,384评论 1赞 345
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,063评论 5赞 340
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,706评论 3赞 324
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,302评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,531评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,321评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,248评论 2赞 352

重新自学学习openGL 之光照多光源

例子

设计

定向光

点光源

聚光

光源合并

推荐阅读更多精彩内容