Lights: change sun light size to be specified as angle
[blender.git] / intern / cycles / render / light.cpp
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include "render/background.h"
18 #include "device/device.h"
19 #include "render/integrator.h"
20 #include "render/film.h"
21 #include "render/graph.h"
22 #include "render/light.h"
23 #include "render/mesh.h"
24 #include "render/nodes.h"
25 #include "render/object.h"
26 #include "render/scene.h"
27 #include "render/shader.h"
28
29 #include "util/util_foreach.h"
30 #include "util/util_hash.h"
31 #include "util/util_path.h"
32 #include "util/util_progress.h"
33 #include "util/util_logging.h"
34
35 CCL_NAMESPACE_BEGIN
36
37 static void shade_background_pixels(Device *device,
38                                     DeviceScene *dscene,
39                                     int width,
40                                     int height,
41                                     vector<float3> &pixels,
42                                     Progress &progress)
43 {
44   /* create input */
45   device_vector<uint4> d_input(device, "background_input", MEM_READ_ONLY);
46   device_vector<float4> d_output(device, "background_output", MEM_READ_WRITE);
47
48   uint4 *d_input_data = d_input.alloc(width * height);
49
50   for (int y = 0; y < height; y++) {
51     for (int x = 0; x < width; x++) {
52       float u = (x + 0.5f) / width;
53       float v = (y + 0.5f) / height;
54
55       uint4 in = make_uint4(__float_as_int(u), __float_as_int(v), 0, 0);
56       d_input_data[x + y * width] = in;
57     }
58   }
59
60   /* compute on device */
61   d_output.alloc(width * height);
62   d_output.zero_to_device();
63   d_input.copy_to_device();
64
65   device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
66
67   DeviceTask main_task(DeviceTask::SHADER);
68   main_task.shader_input = d_input.device_pointer;
69   main_task.shader_output = d_output.device_pointer;
70   main_task.shader_eval_type = SHADER_EVAL_BACKGROUND;
71   main_task.shader_x = 0;
72   main_task.shader_w = width * height;
73   main_task.num_samples = 1;
74   main_task.get_cancel = function_bind(&Progress::get_cancel, &progress);
75
76   /* disabled splitting for now, there's an issue with multi-GPU mem_copy_from */
77   list<DeviceTask> split_tasks;
78   main_task.split(split_tasks, 1, 128 * 128);
79
80   foreach (DeviceTask &task, split_tasks) {
81     device->task_add(task);
82     device->task_wait();
83     d_output.copy_from_device(task.shader_x, 1, task.shader_w);
84   }
85
86   d_input.free();
87
88   float4 *d_output_data = d_output.data();
89
90   pixels.resize(width * height);
91
92   for (int y = 0; y < height; y++) {
93     for (int x = 0; x < width; x++) {
94       pixels[y * width + x].x = d_output_data[y * width + x].x;
95       pixels[y * width + x].y = d_output_data[y * width + x].y;
96       pixels[y * width + x].z = d_output_data[y * width + x].z;
97     }
98   }
99
100   d_output.free();
101 }
102
103 /* Light */
104
105 NODE_DEFINE(Light)
106 {
107   NodeType *type = NodeType::add("light", create);
108
109   static NodeEnum type_enum;
110   type_enum.insert("point", LIGHT_POINT);
111   type_enum.insert("distant", LIGHT_DISTANT);
112   type_enum.insert("background", LIGHT_BACKGROUND);
113   type_enum.insert("area", LIGHT_AREA);
114   type_enum.insert("spot", LIGHT_SPOT);
115   SOCKET_ENUM(type, "Type", type_enum, LIGHT_POINT);
116
117   SOCKET_COLOR(strength, "Strength", make_float3(1.0f, 1.0f, 1.0f));
118
119   SOCKET_POINT(co, "Co", make_float3(0.0f, 0.0f, 0.0f));
120
121   SOCKET_VECTOR(dir, "Dir", make_float3(0.0f, 0.0f, 0.0f));
122   SOCKET_FLOAT(size, "Size", 0.0f);
123
124   SOCKET_VECTOR(axisu, "Axis U", make_float3(0.0f, 0.0f, 0.0f));
125   SOCKET_FLOAT(sizeu, "Size U", 1.0f);
126   SOCKET_VECTOR(axisv, "Axis V", make_float3(0.0f, 0.0f, 0.0f));
127   SOCKET_FLOAT(sizev, "Size V", 1.0f);
128   SOCKET_BOOLEAN(round, "Round", false);
129
130   SOCKET_INT(map_resolution, "Map Resolution", 0);
131
132   SOCKET_FLOAT(spot_angle, "Spot Angle", M_PI_4_F);
133   SOCKET_FLOAT(spot_smooth, "Spot Smooth", 0.0f);
134
135   SOCKET_TRANSFORM(tfm, "Transform", transform_identity());
136
137   SOCKET_BOOLEAN(cast_shadow, "Cast Shadow", true);
138   SOCKET_BOOLEAN(use_mis, "Use Mis", false);
139   SOCKET_BOOLEAN(use_diffuse, "Use Diffuse", true);
140   SOCKET_BOOLEAN(use_glossy, "Use Glossy", true);
141   SOCKET_BOOLEAN(use_transmission, "Use Transmission", true);
142   SOCKET_BOOLEAN(use_scatter, "Use Scatter", true);
143
144   SOCKET_INT(samples, "Samples", 1);
145   SOCKET_INT(max_bounces, "Max Bounces", 1024);
146   SOCKET_UINT(random_id, "Random ID", 0);
147
148   SOCKET_BOOLEAN(is_portal, "Is Portal", false);
149   SOCKET_BOOLEAN(is_enabled, "Is Enabled", true);
150
151   SOCKET_NODE(shader, "Shader", &Shader::node_type);
152
153   return type;
154 }
155
156 Light::Light() : Node(node_type)
157 {
158 }
159
160 void Light::tag_update(Scene *scene)
161 {
162   scene->light_manager->need_update = true;
163 }
164
165 bool Light::has_contribution(Scene *scene)
166 {
167   if (strength == make_float3(0.0f, 0.0f, 0.0f)) {
168     return false;
169   }
170   if (is_portal) {
171     return false;
172   }
173   if (type == LIGHT_BACKGROUND) {
174     return true;
175   }
176   return (shader) ? shader->has_surface_emission : scene->default_light->has_surface_emission;
177 }
178
179 /* Light Manager */
180
181 LightManager::LightManager()
182 {
183   need_update = true;
184   use_light_visibility = false;
185 }
186
187 LightManager::~LightManager()
188 {
189   foreach (IESSlot *slot, ies_slots) {
190     delete slot;
191   }
192 }
193
194 bool LightManager::has_background_light(Scene *scene)
195 {
196   foreach (Light *light, scene->lights) {
197     if (light->type == LIGHT_BACKGROUND && light->is_enabled) {
198       return true;
199     }
200   }
201   return false;
202 }
203
204 void LightManager::disable_ineffective_light(Scene *scene)
205 {
206   /* Make all lights enabled by default, and perform some preliminary checks
207    * needed for finer-tuning of settings (for example, check whether we've
208    * got portals or not).
209    */
210   bool has_portal = false, has_background = false;
211   foreach (Light *light, scene->lights) {
212     light->is_enabled = light->has_contribution(scene);
213     has_portal |= light->is_portal;
214     has_background |= light->type == LIGHT_BACKGROUND;
215   }
216
217   if (has_background) {
218     /* Ignore background light if:
219      * - If unsupported on a device
220      * - If we don't need it (no HDRs etc.)
221      */
222     Shader *shader = (scene->background->shader) ? scene->background->shader :
223                                                    scene->default_background;
224     bool disable_mis = !(has_portal || shader->has_surface_spatial_varying);
225     if (disable_mis) {
226       VLOG(1) << "Background MIS has been disabled.\n";
227       foreach (Light *light, scene->lights) {
228         if (light->type == LIGHT_BACKGROUND) {
229           light->is_enabled = false;
230         }
231       }
232     }
233   }
234 }
235
236 bool LightManager::object_usable_as_light(Object *object)
237 {
238   Mesh *mesh = object->mesh;
239   /* Skip objects with NaNs */
240   if (!object->bounds.valid()) {
241     return false;
242   }
243   /* Skip if we are not visible for BSDFs. */
244   if (!(object->visibility & (PATH_RAY_DIFFUSE | PATH_RAY_GLOSSY | PATH_RAY_TRANSMIT))) {
245     return false;
246   }
247   /* Skip if we have no emission shaders. */
248   /* TODO(sergey): Ideally we want to avoid such duplicated loop, since it'll
249    * iterate all mesh shaders twice (when counting and when calculating
250    * triangle area.
251    */
252   foreach (const Shader *shader, mesh->used_shaders) {
253     if (shader->use_mis && shader->has_surface_emission) {
254       return true;
255     }
256   }
257   return false;
258 }
259
260 void LightManager::device_update_distribution(Device *,
261                                               DeviceScene *dscene,
262                                               Scene *scene,
263                                               Progress &progress)
264 {
265   progress.set_status("Updating Lights", "Computing distribution");
266
267   /* count */
268   size_t num_lights = 0;
269   size_t num_portals = 0;
270   size_t num_background_lights = 0;
271   size_t num_triangles = 0;
272
273   bool background_mis = false;
274
275   foreach (Light *light, scene->lights) {
276     if (light->is_enabled) {
277       num_lights++;
278     }
279     if (light->is_portal) {
280       num_portals++;
281     }
282   }
283
284   foreach (Object *object, scene->objects) {
285     if (progress.get_cancel())
286       return;
287
288     if (!object_usable_as_light(object)) {
289       continue;
290     }
291     /* Count triangles. */
292     Mesh *mesh = object->mesh;
293     size_t mesh_num_triangles = mesh->num_triangles();
294     for (size_t i = 0; i < mesh_num_triangles; i++) {
295       int shader_index = mesh->shader[i];
296       Shader *shader = (shader_index < mesh->used_shaders.size()) ?
297                            mesh->used_shaders[shader_index] :
298                            scene->default_surface;
299
300       if (shader->use_mis && shader->has_surface_emission) {
301         num_triangles++;
302       }
303     }
304   }
305
306   size_t num_distribution = num_triangles + num_lights;
307   VLOG(1) << "Total " << num_distribution << " of light distribution primitives.";
308
309   /* emission area */
310   KernelLightDistribution *distribution = dscene->light_distribution.alloc(num_distribution + 1);
311   float totarea = 0.0f;
312
313   /* triangles */
314   size_t offset = 0;
315   int j = 0;
316
317   foreach (Object *object, scene->objects) {
318     if (progress.get_cancel())
319       return;
320
321     if (!object_usable_as_light(object)) {
322       j++;
323       continue;
324     }
325     /* Sum area. */
326     Mesh *mesh = object->mesh;
327     bool transform_applied = mesh->transform_applied;
328     Transform tfm = object->tfm;
329     int object_id = j;
330     int shader_flag = 0;
331
332     if (!(object->visibility & PATH_RAY_DIFFUSE)) {
333       shader_flag |= SHADER_EXCLUDE_DIFFUSE;
334       use_light_visibility = true;
335     }
336     if (!(object->visibility & PATH_RAY_GLOSSY)) {
337       shader_flag |= SHADER_EXCLUDE_GLOSSY;
338       use_light_visibility = true;
339     }
340     if (!(object->visibility & PATH_RAY_TRANSMIT)) {
341       shader_flag |= SHADER_EXCLUDE_TRANSMIT;
342       use_light_visibility = true;
343     }
344     if (!(object->visibility & PATH_RAY_VOLUME_SCATTER)) {
345       shader_flag |= SHADER_EXCLUDE_SCATTER;
346       use_light_visibility = true;
347     }
348
349     size_t mesh_num_triangles = mesh->num_triangles();
350     for (size_t i = 0; i < mesh_num_triangles; i++) {
351       int shader_index = mesh->shader[i];
352       Shader *shader = (shader_index < mesh->used_shaders.size()) ?
353                            mesh->used_shaders[shader_index] :
354                            scene->default_surface;
355
356       if (shader->use_mis && shader->has_surface_emission) {
357         distribution[offset].totarea = totarea;
358         distribution[offset].prim = i + mesh->tri_offset;
359         distribution[offset].mesh_light.shader_flag = shader_flag;
360         distribution[offset].mesh_light.object_id = object_id;
361         offset++;
362
363         Mesh::Triangle t = mesh->get_triangle(i);
364         if (!t.valid(&mesh->verts[0])) {
365           continue;
366         }
367         float3 p1 = mesh->verts[t.v[0]];
368         float3 p2 = mesh->verts[t.v[1]];
369         float3 p3 = mesh->verts[t.v[2]];
370
371         if (!transform_applied) {
372           p1 = transform_point(&tfm, p1);
373           p2 = transform_point(&tfm, p2);
374           p3 = transform_point(&tfm, p3);
375         }
376
377         totarea += triangle_area(p1, p2, p3);
378       }
379     }
380
381     j++;
382   }
383
384   float trianglearea = totarea;
385
386   /* point lights */
387   float lightarea = (totarea > 0.0f) ? totarea / num_lights : 1.0f;
388   bool use_lamp_mis = false;
389
390   int light_index = 0;
391   foreach (Light *light, scene->lights) {
392     if (!light->is_enabled)
393       continue;
394
395     distribution[offset].totarea = totarea;
396     distribution[offset].prim = ~light_index;
397     distribution[offset].lamp.pad = 1.0f;
398     distribution[offset].lamp.size = light->size;
399     totarea += lightarea;
400
401     if (light->type == LIGHT_DISTANT) {
402       use_lamp_mis |= (light->angle > 0.0f && light->use_mis);
403     }
404     else if (light->type == LIGHT_POINT || light->type == LIGHT_SPOT) {
405       use_lamp_mis |= (light->size > 0.0f && light->use_mis);
406     }
407     else if (light->type == LIGHT_AREA) {
408       use_lamp_mis |= light->use_mis;
409     }
410     else if (light->type == LIGHT_BACKGROUND) {
411       num_background_lights++;
412       background_mis |= light->use_mis;
413     }
414
415     light_index++;
416     offset++;
417   }
418
419   /* normalize cumulative distribution functions */
420   distribution[num_distribution].totarea = totarea;
421   distribution[num_distribution].prim = 0.0f;
422   distribution[num_distribution].lamp.pad = 0.0f;
423   distribution[num_distribution].lamp.size = 0.0f;
424
425   if (totarea > 0.0f) {
426     for (size_t i = 0; i < num_distribution; i++)
427       distribution[i].totarea /= totarea;
428     distribution[num_distribution].totarea = 1.0f;
429   }
430
431   if (progress.get_cancel())
432     return;
433
434   /* update device */
435   KernelIntegrator *kintegrator = &dscene->data.integrator;
436   KernelFilm *kfilm = &dscene->data.film;
437   kintegrator->use_direct_light = (totarea > 0.0f);
438
439   if (kintegrator->use_direct_light) {
440     /* number of emissives */
441     kintegrator->num_distribution = num_distribution;
442
443     /* precompute pdfs */
444     kintegrator->pdf_triangles = 0.0f;
445     kintegrator->pdf_lights = 0.0f;
446
447     /* sample one, with 0.5 probability of light or triangle */
448     kintegrator->num_all_lights = num_lights;
449
450     if (trianglearea > 0.0f) {
451       kintegrator->pdf_triangles = 1.0f / trianglearea;
452       if (num_lights)
453         kintegrator->pdf_triangles *= 0.5f;
454     }
455
456     if (num_lights) {
457       kintegrator->pdf_lights = 1.0f / num_lights;
458       if (trianglearea > 0.0f)
459         kintegrator->pdf_lights *= 0.5f;
460     }
461
462     kintegrator->use_lamp_mis = use_lamp_mis;
463
464     /* bit of an ugly hack to compensate for emitting triangles influencing
465      * amount of samples we get for this pass */
466     kfilm->pass_shadow_scale = 1.0f;
467
468     if (kintegrator->pdf_triangles != 0.0f)
469       kfilm->pass_shadow_scale *= 0.5f;
470
471     if (num_background_lights < num_lights)
472       kfilm->pass_shadow_scale *= (float)(num_lights - num_background_lights) / (float)num_lights;
473
474     /* CDF */
475     dscene->light_distribution.copy_to_device();
476
477     /* Portals */
478     if (num_portals > 0) {
479       kintegrator->portal_offset = light_index;
480       kintegrator->num_portals = num_portals;
481       kintegrator->portal_pdf = background_mis ? 0.5f : 1.0f;
482     }
483     else {
484       kintegrator->num_portals = 0;
485       kintegrator->portal_offset = 0;
486       kintegrator->portal_pdf = 0.0f;
487     }
488   }
489   else {
490     dscene->light_distribution.free();
491
492     kintegrator->num_distribution = 0;
493     kintegrator->num_all_lights = 0;
494     kintegrator->pdf_triangles = 0.0f;
495     kintegrator->pdf_lights = 0.0f;
496     kintegrator->use_lamp_mis = false;
497     kintegrator->num_portals = 0;
498     kintegrator->portal_offset = 0;
499     kintegrator->portal_pdf = 0.0f;
500
501     kfilm->pass_shadow_scale = 1.0f;
502   }
503 }
504
505 static void background_cdf(
506     int start, int end, int res_x, int res_y, const vector<float3> *pixels, float2 *cond_cdf)
507 {
508   int cdf_width = res_x + 1;
509   /* Conditional CDFs (rows, U direction). */
510   for (int i = start; i < end; i++) {
511     float sin_theta = sinf(M_PI_F * (i + 0.5f) / res_y);
512     float3 env_color = (*pixels)[i * res_x];
513     float ave_luminance = average(env_color);
514
515     cond_cdf[i * cdf_width].x = ave_luminance * sin_theta;
516     cond_cdf[i * cdf_width].y = 0.0f;
517
518     for (int j = 1; j < res_x; j++) {
519       env_color = (*pixels)[i * res_x + j];
520       ave_luminance = average(env_color);
521
522       cond_cdf[i * cdf_width + j].x = ave_luminance * sin_theta;
523       cond_cdf[i * cdf_width + j].y = cond_cdf[i * cdf_width + j - 1].y +
524                                       cond_cdf[i * cdf_width + j - 1].x / res_x;
525     }
526
527     float cdf_total = cond_cdf[i * cdf_width + res_x - 1].y +
528                       cond_cdf[i * cdf_width + res_x - 1].x / res_x;
529     float cdf_total_inv = 1.0f / cdf_total;
530
531     /* stuff the total into the brightness value for the last entry, because
532      * we are going to normalize the CDFs to 0.0 to 1.0 afterwards */
533     cond_cdf[i * cdf_width + res_x].x = cdf_total;
534
535     if (cdf_total > 0.0f)
536       for (int j = 1; j < res_x; j++)
537         cond_cdf[i * cdf_width + j].y *= cdf_total_inv;
538
539     cond_cdf[i * cdf_width + res_x].y = 1.0f;
540   }
541 }
542
543 void LightManager::device_update_background(Device *device,
544                                             DeviceScene *dscene,
545                                             Scene *scene,
546                                             Progress &progress)
547 {
548   KernelIntegrator *kintegrator = &dscene->data.integrator;
549   Light *background_light = NULL;
550
551   /* find background light */
552   foreach (Light *light, scene->lights) {
553     if (light->type == LIGHT_BACKGROUND) {
554       background_light = light;
555       break;
556     }
557   }
558
559   /* no background light found, signal renderer to skip sampling */
560   if (!background_light || !background_light->is_enabled) {
561     kintegrator->pdf_background_res_x = 0;
562     kintegrator->pdf_background_res_y = 0;
563     return;
564   }
565
566   progress.set_status("Updating Lights", "Importance map");
567
568   assert(kintegrator->use_direct_light);
569
570   /* get the resolution from the light's size (we stuff it in there) */
571   int2 res = make_int2(background_light->map_resolution, background_light->map_resolution / 2);
572   /* If the resolution isn't set manually, try to find an environment texture. */
573   if (res.x == 0) {
574     Shader *shader = (scene->background->shader) ? scene->background->shader :
575                                                    scene->default_background;
576     foreach (ShaderNode *node, shader->graph->nodes) {
577       if (node->type == EnvironmentTextureNode::node_type) {
578         EnvironmentTextureNode *env = (EnvironmentTextureNode *)node;
579         ImageMetaData metadata;
580         if (env->image_manager && env->image_manager->get_image_metadata(env->slot, metadata)) {
581           res.x = max(res.x, metadata.width);
582           res.y = max(res.y, metadata.height);
583         }
584       }
585     }
586     if (res.x > 0 && res.y > 0) {
587       VLOG(2) << "Automatically set World MIS resolution to " << res.x << " by " << res.y << "\n";
588     }
589   }
590   /* If it's still unknown, just use the default. */
591   if (res.x == 0 || res.y == 0) {
592     res = make_int2(1024, 512);
593     VLOG(2) << "Setting World MIS resolution to default\n";
594   }
595   kintegrator->pdf_background_res_x = res.x;
596   kintegrator->pdf_background_res_y = res.y;
597
598   vector<float3> pixels;
599   shade_background_pixels(device, dscene, res.x, res.y, pixels, progress);
600
601   if (progress.get_cancel())
602     return;
603
604   /* build row distributions and column distribution for the infinite area environment light */
605   int cdf_width = res.x + 1;
606   float2 *marg_cdf = dscene->light_background_marginal_cdf.alloc(res.y + 1);
607   float2 *cond_cdf = dscene->light_background_conditional_cdf.alloc(cdf_width * res.y);
608
609   double time_start = time_dt();
610   if (max(res.x, res.y) < 512) {
611     /* Small enough resolution, faster to do single-threaded. */
612     background_cdf(0, res.y, res.x, res.y, &pixels, cond_cdf);
613   }
614   else {
615     /* Threaded evaluation for large resolution. */
616     const int num_blocks = TaskScheduler::num_threads();
617     const int chunk_size = res.y / num_blocks;
618     int start_row = 0;
619     TaskPool pool;
620     for (int i = 0; i < num_blocks; ++i) {
621       const int current_chunk_size = (i != num_blocks - 1) ? chunk_size : (res.y - i * chunk_size);
622       pool.push(function_bind(&background_cdf,
623                               start_row,
624                               start_row + current_chunk_size,
625                               res.x,
626                               res.y,
627                               &pixels,
628                               cond_cdf));
629       start_row += current_chunk_size;
630     }
631     pool.wait_work();
632   }
633
634   /* marginal CDFs (column, V direction, sum of rows) */
635   marg_cdf[0].x = cond_cdf[res.x].x;
636   marg_cdf[0].y = 0.0f;
637
638   for (int i = 1; i < res.y; i++) {
639     marg_cdf[i].x = cond_cdf[i * cdf_width + res.x].x;
640     marg_cdf[i].y = marg_cdf[i - 1].y + marg_cdf[i - 1].x / res.y;
641   }
642
643   float cdf_total = marg_cdf[res.y - 1].y + marg_cdf[res.y - 1].x / res.y;
644   marg_cdf[res.y].x = cdf_total;
645
646   if (cdf_total > 0.0f)
647     for (int i = 1; i < res.y; i++)
648       marg_cdf[i].y /= cdf_total;
649
650   marg_cdf[res.y].y = 1.0f;
651
652   VLOG(2) << "Background MIS build time " << time_dt() - time_start << "\n";
653
654   /* update device */
655   dscene->light_background_marginal_cdf.copy_to_device();
656   dscene->light_background_conditional_cdf.copy_to_device();
657 }
658
659 void LightManager::device_update_points(Device *, DeviceScene *dscene, Scene *scene)
660 {
661   int num_scene_lights = scene->lights.size();
662
663   int num_lights = 0;
664   foreach (Light *light, scene->lights) {
665     if (light->is_enabled || light->is_portal) {
666       num_lights++;
667     }
668   }
669
670   KernelLight *klights = dscene->lights.alloc(num_lights);
671
672   if (num_lights == 0) {
673     VLOG(1) << "No effective light, ignoring points update.";
674     return;
675   }
676
677   int light_index = 0;
678
679   foreach (Light *light, scene->lights) {
680     if (!light->is_enabled) {
681       continue;
682     }
683
684     float3 co = light->co;
685     Shader *shader = (light->shader) ? light->shader : scene->default_light;
686     int shader_id = scene->shader_manager->get_shader_id(shader);
687     int max_bounces = light->max_bounces;
688     float random = (float)light->random_id * (1.0f / (float)0xFFFFFFFF);
689
690     if (!light->cast_shadow)
691       shader_id &= ~SHADER_CAST_SHADOW;
692
693     if (!light->use_diffuse) {
694       shader_id |= SHADER_EXCLUDE_DIFFUSE;
695       use_light_visibility = true;
696     }
697     if (!light->use_glossy) {
698       shader_id |= SHADER_EXCLUDE_GLOSSY;
699       use_light_visibility = true;
700     }
701     if (!light->use_transmission) {
702       shader_id |= SHADER_EXCLUDE_TRANSMIT;
703       use_light_visibility = true;
704     }
705     if (!light->use_scatter) {
706       shader_id |= SHADER_EXCLUDE_SCATTER;
707       use_light_visibility = true;
708     }
709
710     klights[light_index].type = light->type;
711     klights[light_index].samples = light->samples;
712     klights[light_index].strength[0] = light->strength.x;
713     klights[light_index].strength[1] = light->strength.y;
714     klights[light_index].strength[2] = light->strength.z;
715
716     if (light->type == LIGHT_POINT) {
717       shader_id &= ~SHADER_AREA_LIGHT;
718
719       float radius = light->size;
720       float invarea = (radius > 0.0f) ? 1.0f / (M_PI_F * radius * radius) : 1.0f;
721
722       if (light->use_mis && radius > 0.0f)
723         shader_id |= SHADER_USE_MIS;
724
725       klights[light_index].co[0] = co.x;
726       klights[light_index].co[1] = co.y;
727       klights[light_index].co[2] = co.z;
728
729       klights[light_index].spot.radius = radius;
730       klights[light_index].spot.invarea = invarea;
731     }
732     else if (light->type == LIGHT_DISTANT) {
733       shader_id &= ~SHADER_AREA_LIGHT;
734
735       float angle = light->angle / 2.0f;
736       float radius = tanf(angle);
737       float cosangle = cosf(angle);
738       float area = M_PI_F * radius * radius;
739       float invarea = (area > 0.0f) ? 1.0f / area : 1.0f;
740       float3 dir = light->dir;
741
742       dir = safe_normalize(dir);
743
744       if (light->use_mis && area > 0.0f)
745         shader_id |= SHADER_USE_MIS;
746
747       klights[light_index].co[0] = dir.x;
748       klights[light_index].co[1] = dir.y;
749       klights[light_index].co[2] = dir.z;
750
751       klights[light_index].distant.invarea = invarea;
752       klights[light_index].distant.radius = radius;
753       klights[light_index].distant.cosangle = cosangle;
754     }
755     else if (light->type == LIGHT_BACKGROUND) {
756       uint visibility = scene->background->visibility;
757
758       shader_id &= ~SHADER_AREA_LIGHT;
759       shader_id |= SHADER_USE_MIS;
760
761       if (!(visibility & PATH_RAY_DIFFUSE)) {
762         shader_id |= SHADER_EXCLUDE_DIFFUSE;
763         use_light_visibility = true;
764       }
765       if (!(visibility & PATH_RAY_GLOSSY)) {
766         shader_id |= SHADER_EXCLUDE_GLOSSY;
767         use_light_visibility = true;
768       }
769       if (!(visibility & PATH_RAY_TRANSMIT)) {
770         shader_id |= SHADER_EXCLUDE_TRANSMIT;
771         use_light_visibility = true;
772       }
773       if (!(visibility & PATH_RAY_VOLUME_SCATTER)) {
774         shader_id |= SHADER_EXCLUDE_SCATTER;
775         use_light_visibility = true;
776       }
777     }
778     else if (light->type == LIGHT_AREA) {
779       float3 axisu = light->axisu * (light->sizeu * light->size);
780       float3 axisv = light->axisv * (light->sizev * light->size);
781       float area = len(axisu) * len(axisv);
782       if (light->round) {
783         area *= -M_PI_4_F;
784       }
785       float invarea = (area != 0.0f) ? 1.0f / area : 1.0f;
786       float3 dir = light->dir;
787
788       dir = safe_normalize(dir);
789
790       if (light->use_mis && area != 0.0f)
791         shader_id |= SHADER_USE_MIS;
792
793       klights[light_index].co[0] = co.x;
794       klights[light_index].co[1] = co.y;
795       klights[light_index].co[2] = co.z;
796
797       klights[light_index].area.axisu[0] = axisu.x;
798       klights[light_index].area.axisu[1] = axisu.y;
799       klights[light_index].area.axisu[2] = axisu.z;
800       klights[light_index].area.axisv[0] = axisv.x;
801       klights[light_index].area.axisv[1] = axisv.y;
802       klights[light_index].area.axisv[2] = axisv.z;
803       klights[light_index].area.invarea = invarea;
804       klights[light_index].area.dir[0] = dir.x;
805       klights[light_index].area.dir[1] = dir.y;
806       klights[light_index].area.dir[2] = dir.z;
807     }
808     else if (light->type == LIGHT_SPOT) {
809       shader_id &= ~SHADER_AREA_LIGHT;
810
811       float radius = light->size;
812       float invarea = (radius > 0.0f) ? 1.0f / (M_PI_F * radius * radius) : 1.0f;
813       float spot_angle = cosf(light->spot_angle * 0.5f);
814       float spot_smooth = (1.0f - spot_angle) * light->spot_smooth;
815       float3 dir = light->dir;
816
817       dir = safe_normalize(dir);
818
819       if (light->use_mis && radius > 0.0f)
820         shader_id |= SHADER_USE_MIS;
821
822       klights[light_index].co[0] = co.x;
823       klights[light_index].co[1] = co.y;
824       klights[light_index].co[2] = co.z;
825
826       klights[light_index].spot.radius = radius;
827       klights[light_index].spot.invarea = invarea;
828       klights[light_index].spot.spot_angle = spot_angle;
829       klights[light_index].spot.spot_smooth = spot_smooth;
830       klights[light_index].spot.dir[0] = dir.x;
831       klights[light_index].spot.dir[1] = dir.y;
832       klights[light_index].spot.dir[2] = dir.z;
833     }
834
835     klights[light_index].shader_id = shader_id;
836
837     klights[light_index].max_bounces = max_bounces;
838     klights[light_index].random = random;
839
840     klights[light_index].tfm = light->tfm;
841     klights[light_index].itfm = transform_inverse(light->tfm);
842
843     light_index++;
844   }
845
846   /* TODO(sergey): Consider moving portals update to their own function
847    * keeping this one more manageable.
848    */
849   foreach (Light *light, scene->lights) {
850     if (!light->is_portal)
851       continue;
852     assert(light->type == LIGHT_AREA);
853
854     float3 co = light->co;
855     float3 axisu = light->axisu * (light->sizeu * light->size);
856     float3 axisv = light->axisv * (light->sizev * light->size);
857     float area = len(axisu) * len(axisv);
858     if (light->round) {
859       area *= -M_PI_4_F;
860     }
861     float invarea = (area != 0.0f) ? 1.0f / area : 1.0f;
862     float3 dir = light->dir;
863
864     dir = safe_normalize(dir);
865
866     klights[light_index].co[0] = co.x;
867     klights[light_index].co[1] = co.y;
868     klights[light_index].co[2] = co.z;
869
870     klights[light_index].area.axisu[0] = axisu.x;
871     klights[light_index].area.axisu[1] = axisu.y;
872     klights[light_index].area.axisu[2] = axisu.z;
873     klights[light_index].area.axisv[0] = axisv.x;
874     klights[light_index].area.axisv[1] = axisv.y;
875     klights[light_index].area.axisv[2] = axisv.z;
876     klights[light_index].area.invarea = invarea;
877     klights[light_index].area.dir[0] = dir.x;
878     klights[light_index].area.dir[1] = dir.y;
879     klights[light_index].area.dir[2] = dir.z;
880     klights[light_index].tfm = light->tfm;
881     klights[light_index].itfm = transform_inverse(light->tfm);
882
883     light_index++;
884   }
885
886   VLOG(1) << "Number of lights sent to the device: " << light_index;
887
888   VLOG(1) << "Number of lights without contribution: " << num_scene_lights - light_index;
889
890   dscene->lights.copy_to_device();
891 }
892
893 void LightManager::device_update(Device *device,
894                                  DeviceScene *dscene,
895                                  Scene *scene,
896                                  Progress &progress)
897 {
898   if (!need_update)
899     return;
900
901   VLOG(1) << "Total " << scene->lights.size() << " lights.";
902
903   device_free(device, dscene);
904
905   use_light_visibility = false;
906
907   disable_ineffective_light(scene);
908
909   device_update_points(device, dscene, scene);
910   if (progress.get_cancel())
911     return;
912
913   device_update_distribution(device, dscene, scene, progress);
914   if (progress.get_cancel())
915     return;
916
917   device_update_background(device, dscene, scene, progress);
918   if (progress.get_cancel())
919     return;
920
921   device_update_ies(dscene);
922   if (progress.get_cancel())
923     return;
924
925   if (use_light_visibility != scene->film->use_light_visibility) {
926     scene->film->use_light_visibility = use_light_visibility;
927     scene->film->tag_update(scene);
928   }
929
930   need_update = false;
931 }
932
933 void LightManager::device_free(Device *, DeviceScene *dscene)
934 {
935   dscene->light_distribution.free();
936   dscene->lights.free();
937   dscene->light_background_marginal_cdf.free();
938   dscene->light_background_conditional_cdf.free();
939   dscene->ies_lights.free();
940 }
941
942 void LightManager::tag_update(Scene * /*scene*/)
943 {
944   need_update = true;
945 }
946
947 int LightManager::add_ies_from_file(ustring filename)
948 {
949   string content;
950
951   /* If the file can't be opened, call with an empty line */
952   if (filename.empty() || !path_read_text(filename.c_str(), content)) {
953     content = "\n";
954   }
955
956   return add_ies(ustring(content));
957 }
958
959 int LightManager::add_ies(ustring content)
960 {
961   uint hash = hash_string(content.c_str());
962
963   thread_scoped_lock ies_lock(ies_mutex);
964
965   /* Check whether this IES already has a slot. */
966   size_t slot;
967   for (slot = 0; slot < ies_slots.size(); slot++) {
968     if (ies_slots[slot]->hash == hash) {
969       ies_slots[slot]->users++;
970       return slot;
971     }
972   }
973
974   /* Try to find an empty slot for the new IES. */
975   for (slot = 0; slot < ies_slots.size(); slot++) {
976     if (ies_slots[slot]->users == 0 && ies_slots[slot]->hash == 0) {
977       break;
978     }
979   }
980
981   /* If there's no free slot, add one. */
982   if (slot == ies_slots.size()) {
983     ies_slots.push_back(new IESSlot());
984   }
985
986   ies_slots[slot]->ies.load(content);
987   ies_slots[slot]->users = 1;
988   ies_slots[slot]->hash = hash;
989
990   need_update = true;
991
992   return slot;
993 }
994
995 void LightManager::remove_ies(int slot)
996 {
997   thread_scoped_lock ies_lock(ies_mutex);
998
999   if (slot < 0 || slot >= ies_slots.size()) {
1000     assert(false);
1001     return;
1002   }
1003
1004   assert(ies_slots[slot]->users > 0);
1005   ies_slots[slot]->users--;
1006
1007   /* If the slot has no more users, update the device to remove it. */
1008   need_update |= (ies_slots[slot]->users == 0);
1009 }
1010
1011 void LightManager::device_update_ies(DeviceScene *dscene)
1012 {
1013   /* Clear empty slots. */
1014   foreach (IESSlot *slot, ies_slots) {
1015     if (slot->users == 0) {
1016       slot->hash = 0;
1017       slot->ies.clear();
1018     }
1019   }
1020
1021   /* Shrink the slot table by removing empty slots at the end. */
1022   int slot_end;
1023   for (slot_end = ies_slots.size(); slot_end; slot_end--) {
1024     if (ies_slots[slot_end - 1]->users > 0) {
1025       /* If the preceding slot has users, we found the new end of the table. */
1026       break;
1027     }
1028     else {
1029       /* The slot will be past the new end of the table, so free it. */
1030       delete ies_slots[slot_end - 1];
1031     }
1032   }
1033   ies_slots.resize(slot_end);
1034
1035   if (ies_slots.size() > 0) {
1036     int packed_size = 0;
1037     foreach (IESSlot *slot, ies_slots) {
1038       packed_size += slot->ies.packed_size();
1039     }
1040
1041     /* ies_lights starts with an offset table that contains the offset of every slot,
1042      * or -1 if the slot is invalid.
1043      * Following that table, the packed valid IES lights are stored. */
1044     float *data = dscene->ies_lights.alloc(ies_slots.size() + packed_size);
1045
1046     int offset = ies_slots.size();
1047     for (int i = 0; i < ies_slots.size(); i++) {
1048       int size = ies_slots[i]->ies.packed_size();
1049       if (size > 0) {
1050         data[i] = __int_as_float(offset);
1051         ies_slots[i]->ies.pack(data + offset);
1052         offset += size;
1053       }
1054       else {
1055         data[i] = __int_as_float(-1);
1056       }
1057     }
1058
1059     dscene->ies_lights.copy_to_device();
1060   }
1061 }
1062
1063 CCL_NAMESPACE_END