转自
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 }
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 }
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 }
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 }
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 }
container2.png
container2_specular.png
