精华内容
下载资源
问答
  • OpenGL点光源

    2021-03-20 12:38:28
    OpenGL点光源OpenGL点光源简介源代码剖析主要源代码 OpenGL点光源简介 我们研究了代表定向光的三种主要照明模式(背景、散射和反射)。这是一个以方向为特征的光,但它没有任何位置。因此,它不会在远处减弱(事实上...

    OpenGL点光源简介

    我们研究了代表定向光的三种主要照明模式(背景、散射和反射)。这是一个以方向为特征的光,但它没有任何位置。因此,它不会在远处减弱(事实上,您无法找到从这种光源到物体的距离)。现在,我们将考虑一个点光源,当远离对象时,该光源具有位置和衰减效果。点光的一个经典例子是灯泡。当你在一个小房间里发光时,你没有注意到衰弱的效果,但如果你把它带到外面,你就会立即看到它闪耀的距离的局限性。请注意,定向光的光方向对于点光是动态的。这是因为点光在所有方向上均匀亮起,因此必须通过从向量到点源位置来计算每个要素的方向。这就是为什么我们指定点光的位置,而不是方向。

    点光衰减效果通常称为"衰减"。真实光的衰减受反向平方定律的约束,该定律表示光的强度与光源距离的平方成反比。这在以下公式的数学表达式中进行了描述:
    在这里插入图片描述
    此公式在 3D 图形中效果不好。例如,在一小段距离内,光的力量倾向于无穷大。此外,开发人员除了设置初始力外,没有结果控制。太有限了因此,我们将在公式中添加一些系数,使其更加灵活:

    展开全文
  • OpenGL点光源阴影Point Shadows点光源阴影Point Shadows简介生成深度立方体贴图光空间的变换深度着色器万向阴影贴图显示立方体贴图深度缓冲PCF 点光源阴影Point Shadows简介 上个教程我们学到了如何使用阴影映射技术...

    点光源阴影Point Shadows简介

    上个教程我们学到了如何使用阴影映射技术创建动态阴影。效果不错,但它只适合定向光,因为阴影只是在单一定向光源下生成的。所以它也叫定向阴影映射,深度(阴影)贴图生成自定向光的视角。
    这个技术叫做点光阴影,过去的名字是万向阴影贴图(omnidirectional shadow maps)技术。

    本节代码基于前面的阴影映射教程,所以如果你对传统阴影映射不熟悉,还是建议先读一读阴影映射教程。 算法和定向阴影映射差不多:我们从光的透视图生成一个深度贴图,基于当前fragment位置来对深度贴图采样,然后用储存的深度值和每个fragment进行对比,看看它是否在阴影中。定向阴影映射和万向阴影映射的主要不同在于深度贴图的使用上。

    对于深度贴图,我们需要从一个点光源的所有渲染场景,普通2D深度贴图不能工作;如果我们使用立方体贴图会怎样?因为立方体贴图可以储存6个面的环境数据,它可以将整个场景渲染到立方体贴图的每个面上,把它们当作点光

    展开全文
  • OpenGL点光源的多遍阴影贴图OpenGL点光源的多遍阴影贴图简介源代码剖析主要源代码 OpenGL点光源的多遍阴影贴图简介 我们学习了阴影贴图的基础知识-第一次从光源位置通过使用光方向作为视图矢量,第二次从相机使用第...

    OpenGL点光源的多遍阴影贴图简介

    我们学习了阴影贴图的基础知识-第一次从光源位置通过使用光方向作为视图矢量,第二次从相机使用第二次通过的数据来计算阴影。那时,大多数程序员问自己-这种方法适用于定向光,但是如果我想为点光生成阴影该怎么办?在这种情况下,将没有特定的光方向。今天我们对话的主题是解决这个问题的方法。

    解决方案是认识到一个点光源在所有方向上都发出光的事实,因此阴影贴图的纹理将仅在我们放置的任何地方接收一小部分光线。取而代之的是,我们可以将光放置在立方体纹理的中心。然后,我们将有6个矩形阴影贴图,并且光线将不会在任何地方逸出。每个“光线”将落在这些阴影贴图之一上,然后再进行通常的阴影计算。我们已经在skybox教程中看到了立方体纹理的实际效果,因此我们假设我们已经熟悉它了。

    在实践中,为了模拟所有方向的光线方向,我们将从光源的位置添加6个渲染通道,并且每个渲染通道都有一个唯一的方向。我们将使用主轴方向作为光的方向-正,负X,Y和Z轴,因此,立方体纹理的边将包含到场景中最近像素的距离。通过将这些值与第二遍中每个像素到光线的距离进行比较,我们可以确定像素是否在阴影中。

    看一下下面的图片:

    展开全文
  • 转自 ... 1,多光源 当我们在场景中使用多个光源时,通常使用以下方法:我们需要有一个单独的颜色向量代表片段的输出颜色。对于每一个光源,它对片段...所以场景中的每个光源都会计算它们各自对片段的影响,并结...

    转自

    https://learnopengl-cn.github.io/02%20Lighting/06%20Multiple%20lights/

     

    1,多光源

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

    out vec4 FragColor;
    
    void main()
    {
      // 定义一个输出颜色值
      vec3 output;
      // 将定向光的贡献加到输出中
      output += someFunctionToCalculateDirectionalLight();
      // 对所有的点光源也做相同的事情
      for(int i = 0; i < nr_of_point_lights; i++)
        output += someFunctionToCalculatePointLight();
      // 也加上其它的光源(比如聚光)
      output += someFunctionToCalculateSpotLight();
    
      FragColor = vec4(output, 1.0);
    }

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

    2, 定向光

    我么需要在片段着色器中定义一个函数来计算定向光对相应片段的贡献:它接受一些参数并计算一个定向光照颜色。

    首先,我们需要定义一个定向光源最少所需要的变量。我们可以将这些变量储存在一个叫做DirLight的结构体中,并将它定义为一个uniform。需要的变量在上一节中都介绍过:

    struct DirLight {
        vec3 direction;
    
        vec3 ambient;
        vec3 diffuse;
        vec3 specular;
    };  
    uniform DirLight dirLight;

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

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

    你可以看到,这个函数需要一个DirLight结构体和其它两个向量来进行计算。

    vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
    {
        vec3 lightDir = normalize(-light.direction);
        // 漫反射着色
        float diff = max(dot(normal, lightDir), 0.0);
        // 镜面光着色
        vec3 reflectDir = reflect(-lightDir, normal);
        float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
        // 合并结果
        vec3 ambient  = light.ambient  * vec3(texture(material.diffuse, TexCoords));
        vec3 diffuse  = light.diffuse  * diff * vec3(texture(material.diffuse, TexCoords));
        vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
        return (ambient + diffuse + specular);
    }

    3,点光源

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

    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。我们再一次聪明地从之前的教程中复制粘贴代码,完成了下面这样的函数:

    vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
    {
        vec3 lightDir = normalize(light.position - fragPos);
        // 漫反射着色
        float diff = max(dot(normal, lightDir), 0.0);
        // 镜面光着色
        vec3 reflectDir = reflect(-lightDir, normal);
        float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
        // 衰减
        float distance    = length(light.position - fragPos);
        float attenuation = 1.0 / (light.constant + light.linear * distance + 
                     light.quadratic * (distance * distance));    
        // 合并结果
        vec3 ambient  = light.ambient  * vec3(texture(material.diffuse, TexCoords));
        vec3 diffuse  = light.diffuse  * diff * vec3(texture(material.diffuse, TexCoords));
        vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
        ambient  *= attenuation;
        diffuse  *= attenuation;
        specular *= attenuation;
        return (ambient + diffuse + specular);
    }

    4,合并结果

    现在我们已经定义了一个计算定向光的函数和一个计算点光源的函数了,我们可以将它们合并放到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);    
    
        FragColor = vec4(result, 1.0);
    }

    每个光源类型都将它们的贡献加到了最终的输出颜色上,直到所有的光源都处理完了。最终的颜色包含了场景中所有光源的颜色影响所合并的结果。如果你想的话,你也可以实现一个聚光,并将它的效果加到输出颜色中。我们会将CalcSpotLight函数留给读者作为练习。

    设置定向光结构体的uniform应该非常熟悉了,但是你可能会在想我们该如何设置点光源的uniform值,因为点光源的uniform现在是一个PointLight的数组了。这并不是我们以前讨论过的话题。

    很幸运的是,这并不是很复杂,设置一个结构体数组的uniform和设置一个结构体的uniform是很相似的,但是这一次在访问uniform位置的时候,我们需要定义对应的数组下标值:

    lightingShader.setFloat("pointLights[0].constant", 1.0f);

    在这里我们索引了pointLights数组中的第一个PointLight,并获取了constant变量的位置。但这也意味着不幸的是我们必须对这四个点光源手动设置uniform值,这让点光源本身就产生了28个uniform调用,非常冗长。你也可以尝试将这些抽象出去一点,定义一个点光源类,让它来为你设置uniform值,但最后你仍然要用这种方式设置所有光源的uniform值。

    别忘了,我们还需要为每个点光源定义一个位置向量,所以我们让它们在场景中分散一点。我们会定义另一个glm::vec3数组来包含点光源的位置:

    glm::vec3 pointLightPositions[] = {
        glm::vec3( 0.7f,  0.2f,  2.0f),
        glm::vec3( 2.3f, -3.3f, -4.0f),
        glm::vec3(-4.0f,  2.0f, -12.0f),
        glm::vec3( 0.0f,  0.0f, -3.0f)
    };

     5,最后放上所有源代码:

      1 #include <glad/glad.h>
      2 #include <GLFW/glfw3.h>
      3   
      4 #include <glm/glm.hpp>
      5 #include <glm/gtc/matrix_transform.hpp>
      6 #include <glm/gtc/type_ptr.hpp>
      7 
      8 #include "stb_image.h"
      9 #include "shader_s.h"
     10 #include "Camera.h"
     11 #include <iostream>
     12 //("../res/light/colors.vs", "../res/light/colors.fs")
     13 
     14 void framebuffer_size_callback(GLFWwindow* window, int width, int height);
     15 void mouse_callback(GLFWwindow* window, double xpos, double ypos);
     16 void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
     17 void processInput(GLFWwindow *window);
     18 unsigned int loadTexture(const char *path);
     19 
     20 // settings
     21 const unsigned int SCR_WIDTH = 800;
     22 const unsigned int SCR_HEIGHT = 600;
     23 
     24 // camera
     25 Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
     26 float lastX = SCR_WIDTH / 2.0f;
     27 float lastY = SCR_HEIGHT / 2.0f;
     28 bool firstMouse = true;
     29 
     30 // timing
     31 float deltaTime = 0.0f;
     32 float lastFrame = 0.0f;
     33 
     34 // lighting
     35 glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
     36 
     37 int main()
     38 {
     39     // glfw: initialize and configure
     40     // ------------------------------
     41     glfwInit();
     42     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
     43     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
     44     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
     45 
     46 #ifdef __APPLE__
     47     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
     48 #endif
     49 
     50     // glfw window creation
     51     // --------------------
     52     GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
     53     if (window == NULL)
     54     {
     55         std::cout << "Failed to create GLFW window" << std::endl;
     56         glfwTerminate();
     57         return -1;
     58     }
     59     glfwMakeContextCurrent(window);
     60     glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
     61     glfwSetCursorPosCallback(window, mouse_callback);
     62     glfwSetScrollCallback(window, scroll_callback);
     63 
     64     // tell GLFW to capture our mouse
     65     glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
     66 
     67     // glad: load all OpenGL function pointers
     68     // ---------------------------------------
     69     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
     70     {
     71         std::cout << "Failed to initialize GLAD" << std::endl;
     72         return -1;
     73     }
     74 
     75     // configure global opengl state
     76     // -----------------------------
     77     glEnable(GL_DEPTH_TEST);
     78 
     79 
     80     // build and compile our shader zprogram
     81     // ("../res/light/colors.vs", "../res/light/colors.fs")
     82     Shader lightingShader("../res/light/materials.vs", "../res/light/materials.fs");
     83     Shader lampShader("../res/light/lamp.vs", "../res/light/lamp.fs");
     84     // set up vertex data (and buffer(s)) and configure vertex attributes
     85    // ------------------------------------------------------------------
     86     float vertices[] = {
     87         // positions          // normals           // texture coords
     88         -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,
     89          0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  0.0f,
     90          0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
     91          0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
     92         -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  1.0f,
     93         -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,
     94 
     95         -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
     96          0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  0.0f,
     97          0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
     98          0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
     99         -0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  1.0f,
    100         -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
    101 
    102         -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
    103         -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
    104         -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
    105         -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
    106         -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
    107         -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
    108 
    109          0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
    110          0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
    111          0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
    112          0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
    113          0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
    114          0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
    115 
    116         -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,
    117          0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  1.0f,
    118          0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
    119          0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
    120         -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  0.0f,
    121         -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,
    122 
    123         -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,
    124          0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,
    125          0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
    126          0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
    127         -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f,
    128         -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f
    129     };
    130     // positions all containers
    131     glm::vec3 cubePositions[] = {
    132         glm::vec3(0.0f,  0.0f,  0.0f),
    133         glm::vec3(2.0f,  5.0f, -15.0f),
    134         glm::vec3(-1.5f, -2.2f, -2.5f),
    135         glm::vec3(-3.8f, -2.0f, -12.3f),
    136         glm::vec3(2.4f, -0.4f, -3.5f),
    137         glm::vec3(-1.7f,  3.0f, -7.5f),
    138         glm::vec3(1.3f, -2.0f, -2.5f),
    139         glm::vec3(1.5f,  2.0f, -2.5f),
    140         glm::vec3(1.5f,  0.2f, -1.5f),
    141         glm::vec3(-1.3f,  1.0f, -1.5f)
    142     };
    143     // positions of the point lights
    144     glm::vec3 pointLightPositions[] = {
    145         glm::vec3(0.7f,  0.2f,  2.0f),
    146         glm::vec3(2.3f, -3.3f, -4.0f),
    147         glm::vec3(-4.0f,  2.0f, -12.0f),
    148         glm::vec3(0.0f,  0.0f, -3.0f)
    149     };
    150     // first, configure the cube's VAO (and VBO)
    151     unsigned int VBO, cubeVAO;
    152     glGenVertexArrays(1, &cubeVAO);
    153     glGenBuffers(1, &VBO);
    154 
    155     glBindBuffer(GL_ARRAY_BUFFER, VBO);
    156     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    157 
    158     glBindVertexArray(cubeVAO);
    159     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    160     glEnableVertexAttribArray(0);
    161     glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    162     glEnableVertexAttribArray(1);
    163     glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    164     glEnableVertexAttribArray(2);
    165 
    166     // second, configure the light's VAO (VBO stays the same; the vertices are the same for the light object which is also a 3D cube)
    167     unsigned int lightVAO;
    168     glGenVertexArrays(1, &lightVAO);
    169     glBindVertexArray(lightVAO);
    170 
    171     glBindBuffer(GL_ARRAY_BUFFER, VBO);
    172     // note that we update the lamp's position attribute's stride to reflect the updated buffer data
    173     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    174     glEnableVertexAttribArray(0);
    175 
    176     // load textures (we now use a utility function to keep the code more organized)
    177     // -----------------------------------------------------------------------------
    178     unsigned int diffuseMap = loadTexture("../res/light/container2.png");
    179     unsigned int specularMap = loadTexture("../res/light/container2_specular.png");
    180     //std::cout << diffuseMap;
    181     //unsigned int diffuseMap = loadTexture(FileSystem::getPath("res/light/container2.png").c_str());
    182 
    183     // shader configuration
    184     // --------------------
    185     lightingShader.use();
    186     lightingShader.setInt("material.diffuse", 0);
    187     lightingShader.setInt("material.specular", 1);
    188 
    189 
    190     // render loop
    191     // -----------
    192     while (!glfwWindowShouldClose(window))
    193     {
    194         // per-frame time logic
    195         // --------------------
    196         float currentFrame = glfwGetTime();
    197         deltaTime = currentFrame - lastFrame;
    198         lastFrame = currentFrame;
    199 
    200         // input
    201         // -----
    202         processInput(window);
    203 
    204         // render
    205         // ------
    206         glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
    207         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    208 
    209         // be sure to activate shader when setting uniforms/drawing objects
    210         lightingShader.use();
    211         lightingShader.setVec3("viewPos", camera.Position);
    212         lightingShader.setFloat("material.shininess", 32.0f);
    213 
    214         /*
    215            Here we set all the uniforms for the 5/6 types of lights we have. We have to set them manually and index
    216            the proper PointLight struct in the array to set each uniform variable. This can be done more code-friendly
    217            by defining light types as classes and set their values in there, or by using a more efficient uniform approach
    218            by using 'Uniform buffer objects', but that is something we'll discuss in the 'Advanced GLSL' tutorial.
    219         */
    220         // directional light
    221         lightingShader.setVec3("dirLight.direction", -0.2f, -1.0f, -0.3f);
    222         lightingShader.setVec3("dirLight.ambient", 0.05f, 0.05f, 0.05f);
    223         lightingShader.setVec3("dirLight.diffuse", 0.4f, 0.4f, 0.4f);
    224         lightingShader.setVec3("dirLight.specular", 0.5f, 0.5f, 0.5f);
    225         // point light 1
    226         lightingShader.setVec3("pointLights[0].position", pointLightPositions[0]);
    227         lightingShader.setVec3("pointLights[0].ambient", 0.05f, 0.05f, 0.05f);
    228         lightingShader.setVec3("pointLights[0].diffuse", 0.8f, 0.8f, 0.8f);
    229         lightingShader.setVec3("pointLights[0].specular", 1.0f, 1.0f, 1.0f);
    230         lightingShader.setFloat("pointLights[0].constant", 1.0f);
    231         lightingShader.setFloat("pointLights[0].linear", 0.09);
    232         lightingShader.setFloat("pointLights[0].quadratic", 0.032);
    233         // point light 2
    234         lightingShader.setVec3("pointLights[1].position", pointLightPositions[1]);
    235         lightingShader.setVec3("pointLights[1].ambient", 0.05f, 0.05f, 0.05f);
    236         lightingShader.setVec3("pointLights[1].diffuse", 0.8f, 0.8f, 0.8f);
    237         lightingShader.setVec3("pointLights[1].specular", 1.0f, 1.0f, 1.0f);
    238         lightingShader.setFloat("pointLights[1].constant", 1.0f);
    239         lightingShader.setFloat("pointLights[1].linear", 0.09);
    240         lightingShader.setFloat("pointLights[1].quadratic", 0.032);
    241         // point light 3
    242         lightingShader.setVec3("pointLights[2].position", pointLightPositions[2]);
    243         lightingShader.setVec3("pointLights[2].ambient", 0.05f, 0.05f, 0.05f);
    244         lightingShader.setVec3("pointLights[2].diffuse", 0.8f, 0.8f, 0.8f);
    245         lightingShader.setVec3("pointLights[2].specular", 1.0f, 1.0f, 1.0f);
    246         lightingShader.setFloat("pointLights[2].constant", 1.0f);
    247         lightingShader.setFloat("pointLights[2].linear", 0.09);
    248         lightingShader.setFloat("pointLights[2].quadratic", 0.032);
    249         // point light 4
    250         lightingShader.setVec3("pointLights[3].position", pointLightPositions[3]);
    251         lightingShader.setVec3("pointLights[3].ambient", 0.05f, 0.05f, 0.05f);
    252         lightingShader.setVec3("pointLights[3].diffuse", 0.8f, 0.8f, 0.8f);
    253         lightingShader.setVec3("pointLights[3].specular", 1.0f, 1.0f, 1.0f);
    254         lightingShader.setFloat("pointLights[3].constant", 1.0f);
    255         lightingShader.setFloat("pointLights[3].linear", 0.09);
    256         lightingShader.setFloat("pointLights[3].quadratic", 0.032);
    257         // spotLight
    258         lightingShader.setVec3("spotLight.position", camera.Position);
    259         lightingShader.setVec3("spotLight.direction", camera.Front);
    260         lightingShader.setVec3("spotLight.ambient", 0.0f, 0.0f, 0.0f);
    261         lightingShader.setVec3("spotLight.diffuse", 1.0f, 1.0f, 1.0f);
    262         lightingShader.setVec3("spotLight.specular", 1.0f, 1.0f, 1.0f);
    263         lightingShader.setFloat("spotLight.constant", 1.0f);
    264         lightingShader.setFloat("spotLight.linear", 0.09);
    265         lightingShader.setFloat("spotLight.quadratic", 0.032);
    266         lightingShader.setFloat("spotLight.cutOff", glm::cos(glm::radians(12.5f)));
    267         lightingShader.setFloat("spotLight.outerCutOff", glm::cos(glm::radians(15.0f)));
    268 
    269         // view/projection transformations
    270         glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    271         glm::mat4 view = camera.GetViewMatrix();
    272         lightingShader.setMat4("projection", projection);
    273         lightingShader.setMat4("view", view);
    274 
    275         // world transformation
    276         glm::mat4 model = glm::mat4(1.0f);
    277         lightingShader.setMat4("model", model);
    278 
    279         // bind diffuse map
    280         glActiveTexture(GL_TEXTURE0);
    281         glBindTexture(GL_TEXTURE_2D, diffuseMap);
    282         // bind specular map
    283         glActiveTexture(GL_TEXTURE1);
    284         glBindTexture(GL_TEXTURE_2D, specularMap);
    285 
    286         // render containers
    287         glBindVertexArray(cubeVAO);
    288         for (unsigned int i = 0; i < 10; i++)
    289         {
    290             // calculate the model matrix for each object and pass it to shader before drawing
    291             glm::mat4 model = glm::mat4(1.0f);
    292             model = glm::translate(model, cubePositions[i]);
    293             float angle = 20.0f * i;
    294             model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));
    295             lightingShader.setMat4("model", model);
    296 
    297             glDrawArrays(GL_TRIANGLES, 0, 36);
    298         }
    299 
    300         // also draw the lamp object(s)
    301         lampShader.use();
    302         lampShader.setMat4("projection", projection);
    303         lampShader.setMat4("view", view);
    304 
    305         // we now draw as many light bulbs as we have point lights.
    306         glBindVertexArray(lightVAO);
    307         for (unsigned int i = 0; i < 4; i++)
    308         {
    309             model = glm::mat4(1.0f);
    310             model = glm::translate(model, pointLightPositions[i]);
    311             model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube
    312             lampShader.setMat4("model", model);
    313             glDrawArrays(GL_TRIANGLES, 0, 36);
    314         }
    315 
    316 
    317         // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
    318         // -------------------------------------------------------------------------------
    319         glfwSwapBuffers(window);
    320         glfwPollEvents();
    321     }
    322 
    323     // optional: de-allocate all resources once they've outlived their purpose:
    324     // ------------------------------------------------------------------------
    325     glDeleteVertexArrays(1, &cubeVAO);
    326     glDeleteVertexArrays(1, &lightVAO);
    327     glDeleteBuffers(1, &VBO);
    328 
    329     // glfw: terminate, clearing all previously allocated GLFW resources.
    330     // ------------------------------------------------------------------
    331     glfwTerminate();
    332     return 0;
    333 }
    334 
    335 // process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
    336 // ---------------------------------------------------------------------------------------------------------
    337 void processInput(GLFWwindow *window)
    338 {
    339     if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    340         glfwSetWindowShouldClose(window, true);
    341 
    342     if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
    343         camera.ProcessKeyboard(FORWARD, deltaTime);
    344     if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
    345         camera.ProcessKeyboard(BACKWARD, deltaTime);
    346     if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
    347         camera.ProcessKeyboard(LEFT, deltaTime);
    348     if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
    349         camera.ProcessKeyboard(RIGHT, deltaTime);
    350 }
    351 
    352 // glfw: whenever the window size changed (by OS or user resize) this callback function executes
    353 // ---------------------------------------------------------------------------------------------
    354 void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    355 {
    356     // make sure the viewport matches the new window dimensions; note that width and 
    357     // height will be significantly larger than specified on retina displays.
    358     glViewport(0, 0, width, height);
    359 }
    360 
    361 
    362 // glfw: whenever the mouse moves, this callback is called
    363 // -------------------------------------------------------
    364 void mouse_callback(GLFWwindow* window, double xpos, double ypos)
    365 {
    366     if (firstMouse)
    367     {
    368         lastX = xpos;
    369         lastY = ypos;
    370         firstMouse = false;
    371     }
    372 
    373     float xoffset = xpos - lastX;
    374     float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top
    375 
    376     lastX = xpos;
    377     lastY = ypos;
    378 
    379     camera.ProcessMouseMovement(xoffset, yoffset);
    380 }
    381 
    382 // glfw: whenever the mouse scroll wheel scrolls, this callback is called
    383 // ----------------------------------------------------------------------
    384 void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
    385 {
    386     camera.ProcessMouseScroll(yoffset);
    387 }
    388 unsigned int loadTexture(char const * path)
    389 {
    390     unsigned int textureID;
    391     glGenTextures(1, &textureID);
    392 
    393     int width, height, nrComponents;
    394     unsigned char *data = stbi_load(path, &width, &height, &nrComponents, 0);
    395     if (data)
    396     {
    397         GLenum format;
    398         if (nrComponents == 1)
    399             format = GL_RED;
    400         else if (nrComponents == 3)
    401             format = GL_RGB;
    402         else if (nrComponents == 4)
    403             format = GL_RGBA;
    404 
    405         glBindTexture(GL_TEXTURE_2D, textureID);
    406         glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
    407         glGenerateMipmap(GL_TEXTURE_2D);
    408 
    409         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    410         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    411         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    412         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    413 
    414         stbi_image_free(data);
    415     }
    416     else
    417     {
    418         std::cout << "Texture failed to load at path: " << path << std::endl;
    419         stbi_image_free(data);
    420     }
    421 
    422     return textureID;
    423 }
    TestShader.cpp
     1 #version 330 core
     2 layout (location = 0) in vec3 aPos;
     3 layout (location = 1) in vec3 aNormal;
     4 layout (location = 2) in vec2 aTexCoords;
     5 
     6 out vec3 FragPos;
     7 out vec3 Normal;
     8 out vec2 TexCoords;
     9 
    10 uniform mat4 model;
    11 uniform mat4 view;
    12 uniform mat4 projection;
    13 
    14 void main()
    15 {
    16     FragPos = vec3(model * vec4(aPos, 1.0));
    17     Normal = mat3(transpose(inverse(model))) * aNormal;  
    18     TexCoords = aTexCoords;
    19     
    20     gl_Position = projection * view * vec4(FragPos, 1.0);
    21 }
    material.vs
      1 #version 330 core
      2 out vec4 FragColor;
      3 
      4 struct Material {
      5     sampler2D diffuse;
      6     sampler2D specular;
      7     float shininess;
      8 }; 
      9 
     10 struct DirLight {
     11     vec3 direction;
     12     
     13     vec3 ambient;
     14     vec3 diffuse;
     15     vec3 specular;
     16 };
     17 
     18 struct PointLight {
     19     vec3 position;
     20     
     21     float constant;
     22     float linear;
     23     float quadratic;
     24     
     25     vec3 ambient;
     26     vec3 diffuse;
     27     vec3 specular;
     28 };
     29 
     30 struct SpotLight {
     31     vec3 position;
     32     vec3 direction;
     33     float cutOff;
     34     float outerCutOff;
     35   
     36     float constant;
     37     float linear;
     38     float quadratic;
     39   
     40     vec3 ambient;
     41     vec3 diffuse;
     42     vec3 specular;       
     43 };
     44 
     45 #define NR_POINT_LIGHTS 4
     46 
     47 in vec3 FragPos;
     48 in vec3 Normal;
     49 in vec2 TexCoords;
     50 
     51 uniform vec3 viewPos;
     52 uniform DirLight dirLight;
     53 uniform PointLight pointLights[NR_POINT_LIGHTS];
     54 uniform SpotLight spotLight;
     55 uniform Material material;
     56 
     57 // function prototypes
     58 vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir);
     59 vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir);
     60 vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir);
     61 
     62 void main()
     63 {    
     64     // properties
     65     vec3 norm = normalize(Normal);
     66     vec3 viewDir = normalize(viewPos - FragPos);
     67     
     68     // == =====================================================
     69     // Our lighting is set up in 3 phases: directional, point lights and an optional flashlight
     70     // For each phase, a calculate function is defined that calculates the corresponding color
     71     // per lamp. In the main() function we take all the calculated colors and sum them up for
     72     // this fragment's final color.
     73     // == =====================================================
     74     // phase 1: directional lighting
     75     vec3 result = CalcDirLight(dirLight, norm, viewDir);
     76     // phase 2: point lights
     77     for(int i = 0; i < NR_POINT_LIGHTS; i++)
     78         result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);    
     79     // phase 3: spot light
     80     result += CalcSpotLight(spotLight, norm, FragPos, viewDir);    
     81     
     82     FragColor = vec4(result, 1.0);
     83 }
     84 
     85 // calculates the color when using a directional light.
     86 vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
     87 {
     88     vec3 lightDir = normalize(-light.direction);
     89     // diffuse shading
     90     float diff = max(dot(normal, lightDir), 0.0);
     91     // specular shading
     92     vec3 reflectDir = reflect(-lightDir, normal);
     93     float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
     94     // combine results
     95     vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
     96     vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));
     97     vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
     98     return (ambient + diffuse + specular);
     99 }
    100 
    101 // calculates the color when using a point light.
    102 vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
    103 {
    104     vec3 lightDir = normalize(light.position - fragPos);
    105     // diffuse shading
    106     float diff = max(dot(normal, lightDir), 0.0);
    107     // specular shading
    108     vec3 reflectDir = reflect(-lightDir, normal);
    109     float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
    110     // attenuation
    111     float distance = length(light.position - fragPos);
    112     float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));    
    113     // combine results
    114     vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
    115     vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));
    116     vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
    117     ambient *= attenuation;
    118     diffuse *= attenuation;
    119     specular *= attenuation;
    120     return (ambient + diffuse + specular);
    121 }
    122 
    123 // calculates the color when using a spot light.
    124 vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
    125 {
    126     vec3 lightDir = normalize(light.position - fragPos);
    127     // diffuse shading
    128     float diff = max(dot(normal, lightDir), 0.0);
    129     // specular shading
    130     vec3 reflectDir = reflect(-lightDir, normal);
    131     float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
    132     // attenuation
    133     float distance = length(light.position - fragPos);
    134     float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));    
    135     // spotlight intensity
    136     float theta = dot(lightDir, normalize(-light.direction)); 
    137     float epsilon = light.cutOff - light.outerCutOff;
    138     float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
    139     // combine results
    140     vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
    141     vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));
    142     vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
    143     ambient *= attenuation * intensity;
    144     diffuse *= attenuation * intensity;
    145     specular *= attenuation * intensity;
    146     return (ambient + diffuse + specular);
    147 }
    material.fs
     1 #version 330 core
     2 layout (location = 0) in vec3 aPos;
     3 
     4 uniform mat4 model;
     5 uniform mat4 view;
     6 uniform mat4 projection;
     7 
     8 void main()
     9 {
    10     gl_Position = projection * view * model * vec4(aPos, 1.0);
    11 }
    lamp.vs
    1 #version 330 core
    2 out vec4 FragColor;
    3 
    4 void main()
    5 {
    6     FragColor = vec4(1.0); // set alle 4 vector values to 1.0
    7 }
    lamp.fs

     container2.png

     

    container2_specular.png

     

    转载于:https://www.cnblogs.com/icyhusky/p/10881032.html

    展开全文
  • 《计算机图形学基础》电子工业出版社 第十章第10题代码 通过键盘实现电光源的移动
  • OpenGL光源Multiple lights多光源Multiple lights简介定向光点光源合并结果 多光源Multiple lights简介 我们在前面的教程中已经学习了许多关于OpenGL中光照的知识,其中包括冯氏着色(Phong Shading)、材质...
  • 但是要得到点光源阴影贴图要考虑到的是:如何渲染出周围所有的场景,像摄像机它是有一定视角的,而点光源确是360°全面照射,因此对于点光源的阴影贴图一张肯定是不够的,它只能展示出一个方向 下图是90°透视投影...
  • 一、定义短多个光源 //平行光 LightDirectional lightD(glm::vec3(10.0f, 10.0f, -5.0f), glm::vec3(glm::radians(90.0f), glm::...//点光源 LightPoint lightP0(glm::vec3(1.0f, .0f, .0f), glm::vec3(glm::radia...
  • OpenGL: 光源

    千次阅读 2014-03-05 09:45:38
    代码如下:#define GLUT_DISABLE_ATEXIT_HACK #include "gl/glut.h" #pragma comment(lib, "glut32.lib") //显示 回调函数 void OnDisplay(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); ...
  • 顶点着色器代码: // Simple Diffuse lighting Shader // Vertex Shader // Richard S. Wright Jr. // OpenGL SuperBible #version 130 // Incoming per vertex... position and normal in vec4 vVertex; in vec3...
  • 【一步步学OpenGL 20】 -《点光源

    千次阅读 2016-11-09 10:51:38
    教程 20点光源原文: http://ogldev.atspace.co.uk/www/tutorial20/tutorial20.htmlCSDN完整版专栏: http://blog.csdn.net/column/details/13062.html背景之前已经学习了三个基本的光照模型(环境光,漫射光和镜面...
  • OpenGL光源位置

    2019-10-03 00:57:53
    OpenGL提供了多种形式的光源,如点光源、平行光源和聚光灯光源等。所有光源都使用 glLight*接口来设置光源属性,其中包括 glLight{if} 和 glLight{if}v 两类。 1、示例光源 GLfloat ambient[] = {0.3f, 0.3f, 0.3f, ...
  • 常规的 光源类型 有三种。...稍复杂些的为点光源,最复杂的为聚光灯。总体说来,在可编程管线中原理是一样的。在OpenGL代码中传入必要的参数,在shader中进行相关的计算绘制出效果。本文分别介绍三种效果的shader实现。
  • OpenGL学习之路18---- 点光源

    千次阅读 2018-05-12 17:31:41
    代码放在github上 根据教程:ogldev一步步开始,记录学习历程 之前学习了三个基于平行光的光照模型,相关博文如下: ...点光源即为有起点的光源,有衰减现象(即离光源越远光线越弱)。生活中常见的点光...
  • OpenGL基础18:光照基础这一章里面讲了几种常见光源,先看平行光吧 一个很好的例子就是太阳光,因为离我们的距离过远,所以太阳光的特点就是“无限范围”且平行 所有的光线都是平行的,这样的话物体与光源的相对...
  • 背景前两篇文章谈了光照的原理,本文记录了在了解了原理后调试代码的过程及遇到的一些问题和想法,实现主要参考了红宝书上点光源着色器的代码。需求是这样的,我们现在要实现一个点光源,让这个点光源照亮天空盒的...
  • OpenGL教程翻译 第二十课 点光源

    千次阅读 2015-09-29 11:34:21
    第二十课 点光源原文地址:http://ogldev.atspace.co.uk/(源码请从原文主页下载)背景知识基于平行光,我们...我们来定义一下点光源点光源有起点和衰减效果,并且当物体远离点光源时这种衰减效果变得更为明显。灯泡
  • 在3D世界中,模拟点光源实现对墙壁的光照。效果还是非常不错的。 思路如下: 准备一张墙壁图像。 自动生成墙壁的法线纹理。 模拟点光源。 添加漫反射。 随着时间变换进行规律性移动。 代码如下: #iChannel0"file:...
  • OpenGL光源光照基础

    2017-11-10 11:22:25
    OpenGL光照模型中,除非一个物体自己会发光,否则它将受到3种不同类型的光的照射:环境光(ambient)、散射光(diffuse)和镜面光(specular)。 全局环境光 在我们没有用到光照之前,我们也能够看到场景中绘制的物体,...
  • opengl-多光源

    2018-12-24 11:27:45
    opengl-多光源光源定向光点光源合并结果 多光源 为了在场景中使用多个光源,我们希望将光照计算封装到GLSL函数中。这样做的原因是,每一种光源都需要一种不同的计算方法,而一旦我们想对多个光源进行光照计算时,...
  • opengl基本代码

    2012-03-02 18:52:30
    主要是设置一些OpenGL的状态开关,如颜色模式(RGBA或ALPHA)的选择,是否作光照处理(若有的话,还需设置光源的特性),深度检验,裁剪等等。OpenGL的库函数构造几何物体对象的数学描述,包括线面的位置和拓扑...
  • 背景之前已经学习了三个基本的光照模型(环境光,漫射光和镜面反射光),这三种模型都是基于平行光的...点光源的经典例子是灯泡,灯泡在屋子里可能效果不明显,但是拿到室外就会明显看出它的衰减效果了。注意之前平...
  • 假设所有光线都是平行的,所以只需要计算一个物体和光源的角度就可以了(不需要在顶点或者片段着色器中进行计算了) 修改片段着色器中光的属性position变为齐次坐标 uniform vec4 lightPos; //光的结构体(属性) ...
  • 代码比较乱,还请见谅,如果有帮助到您,请给俺个赞(毕竟花了好久调试出来的,满眼都是泪) 一:实现效果 二:代码实现 通过小键盘控制光源的移动 #include <windows.h> #include <GL/glut.h> #...
  • openGL光源概念

    2014-09-06 13:29:00
    环境光——经过多次反射而来的光称为环境光,无法确定其最初的方向,但当特定的光源关闭后,它们将消失. 全局环境光——每个光源都能对场景提供环境光。此外,还有一个环境光,它不来自任何特定的光源,称之为全局...
  • OpenGL光源的三种移动区别

    千次阅读 2011-12-02 10:51:33
    1.光源不动:需要在设置完视图模型...伪代码如下: glmatrixmode(gl_projection); glloadidentity(); xxxxxxxxxx; glmatrixmode(gl_modelview); glloadidentity(); glfloat light_position []={1.0,1.0,1.0,1.0}
  • [OpenGL] 延迟渲染 - 多个点光源

    千次阅读 2019-01-27 15:12:47
     在前向渲染中,如果场景中有N个物体,M个光源,那么我们就需要对于每个光源下,每个物体逐一绘制,这也就意味着我们需要绘制N * M次。这意味着光照计算除了会随着光的数量增加而增加复杂度,还会随着场景复杂度而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,773
精华内容 1,909
关键字:

opengl点光源代码